From 004ab612e51ed07cccd26ebc3f5db090336b97b6 Mon Sep 17 00:00:00 2001 From: Pritham Marupaka Date: Tue, 29 Jul 2025 11:12:36 -0400 Subject: [PATCH 01/26] Respect Accept-Conjure-Error-Parameter-Format --- build.gradle | 1 + .../java/undertow/runtime/ConjureError.java | 6 +++++ .../undertow/runtime/ConjureExceptions.java | 25 ++++++++++++++++++- 3 files changed, 31 insertions(+), 1 deletion(-) diff --git a/build.gradle b/build.gradle index bc5bc20a4..ef3a6944d 100644 --- a/build.gradle +++ b/build.gradle @@ -59,6 +59,7 @@ allprojects { repositories { mavenCentral() { metadataSources { mavenPom(); ignoreGradleMetadataRedirection() } } + mavenLocal() } configurations.all { diff --git a/conjure-java-undertow-runtime/src/main/java/com/palantir/conjure/java/undertow/runtime/ConjureError.java b/conjure-java-undertow-runtime/src/main/java/com/palantir/conjure/java/undertow/runtime/ConjureError.java index 9ac4865a5..7cd60eae7 100644 --- a/conjure-java-undertow-runtime/src/main/java/com/palantir/conjure/java/undertow/runtime/ConjureError.java +++ b/conjure-java-undertow-runtime/src/main/java/com/palantir/conjure/java/undertow/runtime/ConjureError.java @@ -92,6 +92,12 @@ static ConjureError fromServiceException(ServiceException exception) { return new ConjureError(errorType.code().name(), errorType.name(), exception.getErrorInstanceId(), parameters); } + static ConjureError fromServiceExceptionWithJsonParameters(ServiceException exception) { + Map parameters = getParametersFromArgs(exception.getArgs()); + ErrorType errorType = exception.getErrorType(); + return new ConjureError(errorType.code().name(), errorType.name(), exception.getErrorInstanceId(), parameters); + } + /** * Creates a {@link ConjureError} from a {@link ServiceException} where the parameter values are serialized as JSON. * Currently, this should only be used when clients send a request with a custom header specifying the parameter diff --git a/conjure-java-undertow-runtime/src/main/java/com/palantir/conjure/java/undertow/runtime/ConjureExceptions.java b/conjure-java-undertow-runtime/src/main/java/com/palantir/conjure/java/undertow/runtime/ConjureExceptions.java index 5a40505ed..0de6c78de 100644 --- a/conjure-java-undertow-runtime/src/main/java/com/palantir/conjure/java/undertow/runtime/ConjureExceptions.java +++ b/conjure-java-undertow-runtime/src/main/java/com/palantir/conjure/java/undertow/runtime/ConjureExceptions.java @@ -64,6 +64,15 @@ public enum ConjureExceptions implements ExceptionHandler { // Log at most once every second private static final RateLimiter qosLoggingRateLimiter = RateLimiter.create(1); + private enum ConjureErrorParamsDecoder implements ConjureErrorParameterFormatRequestDecodingAdapter { + INSTANCE; + + @Override + public String getFirstHeader(HeaderMap response, String headerName) { + return response.getFirst(headerName); + } + } + @SuppressWarnings("CyclomaticComplexity") @Override public void handle(HttpServerExchange exchange, Throwable throwable) { @@ -75,7 +84,13 @@ public void handle(HttpServerExchange exchange, Throwable throwable) { // Conjure. checkedServiceException(exchange, checkedServiceException); } else if (throwable instanceof ServiceException serviceException) { - serviceException(exchange, serviceException); + Optional maybeErrorParamFormatHeader = ConjureErrorParameterFormats.parseFromRequest(exchange.getRequestHeaders(), ConjureErrorParamsDecoder.INSTANCE); + if ( maybeErrorParamFormatHeader.isPresent() + && maybeErrorParamFormatHeader.get().equals(ConjureErrorParameterFormat.JSON_FORMAT)) { + serviceExceptionWithJsonParameterValues(exchange, serviceException); + } else { + serviceException(exchange, serviceException); + } } else if (throwable instanceof QosException qosException) { qosException(exchange, qosException); } else if (throwable instanceof RemoteException remoteException) { @@ -156,6 +171,14 @@ public String getFirstHeader(HeaderMap requestHeaderMap, String headerName) { } } + private static void serviceExceptionWithJsonParameterValues(HttpServerExchange exchange, ServiceException exception) { + log(exception); + writeResponse( + exchange, + Optional.of(ConjureError.fromServiceExceptionWithJsonParameters(exception)), + exception.getErrorType().httpErrorCode()); + } + private static void qosException(HttpServerExchange exchange, QosException qosException) { qosException.accept(QOS_EXCEPTION_HEADERS).accept(exchange); QosReasons.encodeToResponse(qosException.getReason(), exchange, UndertowQosResponseEncodingAdapter.INSTANCE); From 84aeda125bf08f01a3d36f180c5b6253a8e5769f Mon Sep 17 00:00:00 2001 From: Pritham Marupaka Date: Tue, 29 Jul 2025 11:57:27 -0400 Subject: [PATCH 02/26] clean up handle codepath --- .../undertow/runtime/ConjureExceptions.java | 25 +------------------ 1 file changed, 1 insertion(+), 24 deletions(-) diff --git a/conjure-java-undertow-runtime/src/main/java/com/palantir/conjure/java/undertow/runtime/ConjureExceptions.java b/conjure-java-undertow-runtime/src/main/java/com/palantir/conjure/java/undertow/runtime/ConjureExceptions.java index 0de6c78de..5a40505ed 100644 --- a/conjure-java-undertow-runtime/src/main/java/com/palantir/conjure/java/undertow/runtime/ConjureExceptions.java +++ b/conjure-java-undertow-runtime/src/main/java/com/palantir/conjure/java/undertow/runtime/ConjureExceptions.java @@ -64,15 +64,6 @@ public enum ConjureExceptions implements ExceptionHandler { // Log at most once every second private static final RateLimiter qosLoggingRateLimiter = RateLimiter.create(1); - private enum ConjureErrorParamsDecoder implements ConjureErrorParameterFormatRequestDecodingAdapter { - INSTANCE; - - @Override - public String getFirstHeader(HeaderMap response, String headerName) { - return response.getFirst(headerName); - } - } - @SuppressWarnings("CyclomaticComplexity") @Override public void handle(HttpServerExchange exchange, Throwable throwable) { @@ -84,13 +75,7 @@ public void handle(HttpServerExchange exchange, Throwable throwable) { // Conjure. checkedServiceException(exchange, checkedServiceException); } else if (throwable instanceof ServiceException serviceException) { - Optional maybeErrorParamFormatHeader = ConjureErrorParameterFormats.parseFromRequest(exchange.getRequestHeaders(), ConjureErrorParamsDecoder.INSTANCE); - if ( maybeErrorParamFormatHeader.isPresent() - && maybeErrorParamFormatHeader.get().equals(ConjureErrorParameterFormat.JSON_FORMAT)) { - serviceExceptionWithJsonParameterValues(exchange, serviceException); - } else { - serviceException(exchange, serviceException); - } + serviceException(exchange, serviceException); } else if (throwable instanceof QosException qosException) { qosException(exchange, qosException); } else if (throwable instanceof RemoteException remoteException) { @@ -171,14 +156,6 @@ public String getFirstHeader(HeaderMap requestHeaderMap, String headerName) { } } - private static void serviceExceptionWithJsonParameterValues(HttpServerExchange exchange, ServiceException exception) { - log(exception); - writeResponse( - exchange, - Optional.of(ConjureError.fromServiceExceptionWithJsonParameters(exception)), - exception.getErrorType().httpErrorCode()); - } - private static void qosException(HttpServerExchange exchange, QosException qosException) { qosException.accept(QOS_EXCEPTION_HEADERS).accept(exchange); QosReasons.encodeToResponse(qosException.getReason(), exchange, UndertowQosResponseEncodingAdapter.INSTANCE); From e0014bebc03559323edefd45a77cbf30c351d5e2 Mon Sep 17 00:00:00 2001 From: Pritham Marupaka Date: Tue, 29 Jul 2025 14:11:11 -0400 Subject: [PATCH 03/26] remove mavenLocal --- build.gradle | 1 - .../conjure/java/undertow/runtime/ConjureError.java | 6 ------ 2 files changed, 7 deletions(-) diff --git a/build.gradle b/build.gradle index ef3a6944d..bc5bc20a4 100644 --- a/build.gradle +++ b/build.gradle @@ -59,7 +59,6 @@ allprojects { repositories { mavenCentral() { metadataSources { mavenPom(); ignoreGradleMetadataRedirection() } } - mavenLocal() } configurations.all { diff --git a/conjure-java-undertow-runtime/src/main/java/com/palantir/conjure/java/undertow/runtime/ConjureError.java b/conjure-java-undertow-runtime/src/main/java/com/palantir/conjure/java/undertow/runtime/ConjureError.java index 7cd60eae7..9ac4865a5 100644 --- a/conjure-java-undertow-runtime/src/main/java/com/palantir/conjure/java/undertow/runtime/ConjureError.java +++ b/conjure-java-undertow-runtime/src/main/java/com/palantir/conjure/java/undertow/runtime/ConjureError.java @@ -92,12 +92,6 @@ static ConjureError fromServiceException(ServiceException exception) { return new ConjureError(errorType.code().name(), errorType.name(), exception.getErrorInstanceId(), parameters); } - static ConjureError fromServiceExceptionWithJsonParameters(ServiceException exception) { - Map parameters = getParametersFromArgs(exception.getArgs()); - ErrorType errorType = exception.getErrorType(); - return new ConjureError(errorType.code().name(), errorType.name(), exception.getErrorInstanceId(), parameters); - } - /** * Creates a {@link ConjureError} from a {@link ServiceException} where the parameter values are serialized as JSON. * Currently, this should only be used when clients send a request with a custom header specifying the parameter From 39127f6e4057dd1290c7bede114d70cd4072c412 Mon Sep 17 00:00:00 2001 From: svc-changelog Date: Tue, 29 Jul 2025 18:14:26 +0000 Subject: [PATCH 04/26] Add generated changelog entries --- changelog/@unreleased/pr-2588.v2.yml | 6 ++++++ 1 file changed, 6 insertions(+) create mode 100644 changelog/@unreleased/pr-2588.v2.yml diff --git a/changelog/@unreleased/pr-2588.v2.yml b/changelog/@unreleased/pr-2588.v2.yml new file mode 100644 index 000000000..f09bbb1ef --- /dev/null +++ b/changelog/@unreleased/pr-2588.v2.yml @@ -0,0 +1,6 @@ +type: improvement +improvement: + description: When the `Accept-Conjure-Error-Parameter-Format` header is `JSON`, + servers serialize error parameters as JSON, instead of using `Objects.toString`. + links: + - https://github.com/palantir/conjure-java/pull/2588 From 35dd7d305e9a36153e1803b56fdcfa82de60d2f3 Mon Sep 17 00:00:00 2001 From: svc-autorelease Date: Tue, 29 Jul 2025 19:50:15 +0000 Subject: [PATCH 05/26] Release 8.51.0-rc1 [skip ci] From 7e791a9cf1eba83abd737db5d1897ec64eb556c4 Mon Sep 17 00:00:00 2001 From: Pritham Marupaka Date: Thu, 31 Jul 2025 11:25:44 -0400 Subject: [PATCH 06/26] Testing JSON -> Objects.toString conversion to maintain backcompat --- build.gradle | 1 + .../product/DialogueEteEndpoints.java | 38 ++++++ .../com/palantir/product/EteServiceAsync.java | 29 +++++ .../palantir/product/EteServiceBlocking.java | 47 ++++++-- .../com/palantir/product/ConjureErrors.java | 69 ++++++++++- .../product/OptionalCollectionExample.java | 71 +++++++++++ .../com/palantir/product/StringExample.java | 112 ++++++++++++++++++ .../com/palantir/product/EteService.java | 12 ++ .../palantir/product/EteServiceEndpoints.java | 50 ++++++++ .../palantir/product/UndertowEteService.java | 9 ++ .../conjure/java/JerseyEteResource.java | 6 + .../conjure/java/UndertowEteResource.java | 21 ++++ .../conjure/java/UndertowServiceEteTest.java | 47 ++++++++ .../ParameterizedConjureGenerationTest.java | 23 +++- .../src/test/resources/ete-service.yml | 12 ++ versions.lock | 20 ++-- versions.props | 2 +- 17 files changed, 549 insertions(+), 20 deletions(-) create mode 100644 conjure-java-core/src/integrationInput/java/errors/com/palantir/product/OptionalCollectionExample.java create mode 100644 conjure-java-core/src/integrationInput/java/errors/com/palantir/product/StringExample.java diff --git a/build.gradle b/build.gradle index bc5bc20a4..ef3a6944d 100644 --- a/build.gradle +++ b/build.gradle @@ -59,6 +59,7 @@ allprojects { repositories { mavenCentral() { metadataSources { mavenPom(); ignoreGradleMetadataRedirection() } } + mavenLocal() } configurations.all { diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/DialogueEteEndpoints.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/DialogueEteEndpoints.java index adc77ee3a..0009b2c0f 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/DialogueEteEndpoints.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/DialogueEteEndpoints.java @@ -882,6 +882,44 @@ public String version() { } }, + /** + * This endpoint is used to test that that error parameters serialized as JSON or using Objects.toString + * are both handled correctly by the clients that return "rich" exceptions (which are sub-types of + * RemoteException). + */ + errorParameterSerialization { + private final PathTemplate pathTemplate = PathTemplate.builder() + .fixed("base") + .fixed("errors") + .fixed("serialization") + .build(); + + @Override + public void renderPath(ListMultimap params, UrlBuilder url) { + pathTemplate.fill(params, url); + } + + @Override + public HttpMethod httpMethod() { + return HttpMethod.GET; + } + + @Override + public String serviceName() { + return "EteService"; + } + + @Override + public String endpointName() { + return "errorParameterSerialization"; + } + + @Override + public String version() { + return "1.2.3"; + } + }, + aliasLongEndpoint { private final PathTemplate pathTemplate = PathTemplate.builder().fixed("base").fixed("alias-long").build(); diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceAsync.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceAsync.java index c5ee0fde5..e4f65beff 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceAsync.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceAsync.java @@ -176,6 +176,16 @@ ListenableFuture> optionalEnumQuery( @ClientEndpoint(method = "GET", path = "/base/errors/header") ListenableFuture jsonErrorsHeader(AuthHeader authHeader, String headerParameter); + /** + * This endpoint is used to test that that error parameters serialized as JSON or using Objects.toString + * are both handled correctly by the clients that return "rich" exceptions (which are sub-types of + * RemoteException). + * + * @apiNote {@code GET /base/errors/serialization} + */ + @ClientEndpoint(method = "GET", path = "/base/errors/serialization") + ListenableFuture errorParameterSerialization(AuthHeader authHeader, String headerParameter); + /** @apiNote {@code GET /base/alias-long} */ @ClientEndpoint(method = "GET", path = "/base/alias-long") ListenableFuture> aliasLongEndpoint(AuthHeader authHeader, Optional input); @@ -378,6 +388,12 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur private final Deserializer jsonErrorsHeaderDeserializer = _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final EndpointChannel errorParameterSerializationChannel = + _endpointChannelFactory.endpoint(DialogueEteEndpoints.errorParameterSerialization); + + private final Deserializer errorParameterSerializationDeserializer = + _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final EndpointChannel aliasLongEndpointChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.aliasLongEndpoint); @@ -670,6 +686,19 @@ public ListenableFuture jsonErrorsHeader(AuthHeader authHeader, String h return _runtime.clients().call(jsonErrorsHeaderChannel, _request.build(), jsonErrorsHeaderDeserializer); } + @Override + public ListenableFuture errorParameterSerialization(AuthHeader authHeader, String headerParameter) { + Request.Builder _request = Request.builder(); + _request.putHeaderParams("Authorization", authHeader.toString()); + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", _plainSerDe.serializeString(headerParameter)); + return _runtime.clients() + .call( + errorParameterSerializationChannel, + _request.build(), + errorParameterSerializationDeserializer); + } + @Override public ListenableFuture> aliasLongEndpoint( AuthHeader authHeader, Optional input) { diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceBlocking.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceBlocking.java index 728d42562..3d670d2b9 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceBlocking.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceBlocking.java @@ -6,6 +6,7 @@ import com.palantir.dialogue.Channel; import com.palantir.dialogue.ConjureRuntime; import com.palantir.dialogue.Deserializer; +import com.palantir.dialogue.DeserializerArgs; import com.palantir.dialogue.DialogueService; import com.palantir.dialogue.DialogueServiceFactory; import com.palantir.dialogue.Endpoint; @@ -18,14 +19,10 @@ import com.palantir.ri.ResourceIdentifier; import com.palantir.tokens.auth.AuthHeader; import com.palantir.tokens.auth.BearerToken; +import errors.com.palantir.product.ConjureErrors; +import errors.com.palantir.product.ConjureErrors.ErrorWithComplexArgsException; +import errors.com.palantir.product.ConjureErrors.ErrorWithComplexArgsSerializableError; import java.io.InputStream; -import java.lang.Boolean; -import java.lang.Double; -import java.lang.Integer; -import java.lang.Long; -import java.lang.Override; -import java.lang.String; -import java.lang.Void; import java.time.OffsetDateTime; import java.util.List; import java.util.Objects; @@ -175,6 +172,16 @@ Optional optionalQueryExter @ClientEndpoint(method = "GET", path = "/base/errors/header") String jsonErrorsHeader(AuthHeader authHeader, String headerParameter); + /** + * This endpoint is used to test that that error parameters serialized as JSON or using Objects.toString + * are both handled correctly by the clients that return "rich" exceptions (which are sub-types of + * RemoteException). + * + * @apiNote {@code GET /base/errors/serialization} + */ + @ClientEndpoint(method = "GET", path = "/base/errors/serialization") + String errorParameterSerialization(AuthHeader authHeader, String headerParameter); + /** @apiNote {@code GET /base/alias-long} */ @ClientEndpoint(method = "GET", path = "/base/alias-long") Optional aliasLongEndpoint(AuthHeader authHeader, Optional input); @@ -377,6 +384,19 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con private final Deserializer jsonErrorsHeaderDeserializer = _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final EndpointChannel errorParameterSerializationChannel = + _endpointChannelFactory.endpoint(DialogueEteEndpoints.errorParameterSerialization); + + private final Deserializer errorParameterSerializationDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); + private final EndpointChannel aliasLongEndpointChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.aliasLongEndpoint); @@ -666,6 +686,19 @@ public String jsonErrorsHeader(AuthHeader authHeader, String headerParameter) { .callBlocking(jsonErrorsHeaderChannel, _request.build(), jsonErrorsHeaderDeserializer); } + @Override + public String errorParameterSerialization(AuthHeader authHeader, String headerParameter) { + Request.Builder _request = Request.builder(); + _request.putHeaderParams("Authorization", authHeader.toString()); + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", _plainSerDe.serializeString(headerParameter)); + return _runtime.clients() + .callBlocking( + errorParameterSerializationChannel, + _request.build(), + errorParameterSerializationDeserializer); + } + @Override public Optional aliasLongEndpoint(AuthHeader authHeader, Optional input) { Request.Builder _request = Request.builder(); diff --git a/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureErrors.java b/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureErrors.java index 25079e171..bbf2f2cc3 100644 --- a/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureErrors.java +++ b/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureErrors.java @@ -1,13 +1,19 @@ package errors.com.palantir.product; +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.palantir.conjure.java.api.errors.AbstractSerializableError; import com.palantir.conjure.java.api.errors.ErrorType; import com.palantir.conjure.java.api.errors.RemoteException; +import com.palantir.conjure.java.api.errors.SerializableError; import com.palantir.conjure.java.api.errors.ServiceException; import com.palantir.logsafe.Preconditions; import com.palantir.logsafe.Safe; import com.palantir.logsafe.SafeArg; import com.palantir.logsafe.Unsafe; import com.palantir.logsafe.UnsafeArg; +import java.util.Objects; +import java.util.Optional; import javax.annotation.Nullable; import javax.annotation.processing.Generated; import org.jetbrains.annotations.Contract; @@ -21,7 +27,7 @@ public final class ConjureErrors { /** Cause argument conflicts with reserved Throwable cause parameter. */ public static final ErrorType CONFLICTING_CAUSE_UNSAFE_ARG = ErrorType.create(ErrorType.Code.INTERNAL, "Conjure:ConflictingCauseUnsafeArg"); - + /** Error with complex arguments. */ public static final ErrorType ERROR_WITH_COMPLEX_ARGS = ErrorType.create(ErrorType.Code.INTERNAL, "Conjure:ErrorWithComplexArgs"); @@ -330,4 +336,65 @@ public static boolean isInvalidTypeDefinition(RemoteException remoteException) { Preconditions.checkNotNull(remoteException, "remote exception must not be null"); return INVALID_TYPE_DEFINITION.name().equals(remoteException.getError().errorName()); } + + // HAND-WRITTEN CODE BELOW + public static record ErrorWithComplexArgsParameters( + @JsonProperty("stringExample") @Safe StringExample stringExample, + @JsonProperty("primitive") @Safe long primitive, + @JsonProperty("collectionExample") @Safe CollectionExample collectionExample, + @JsonProperty("optionalExample") @Safe OptionalExample optionalExample, + @JsonProperty("optionalCollectionExample") @Safe OptionalCollectionExample optionalCollectionExample, + @JsonProperty("enumExample") @Safe EnumExample enumExample) {} + + public static final class ErrorWithComplexArgsSerializableError + extends AbstractSerializableError { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + ErrorWithComplexArgsSerializableError( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorName") @Safe String errorName, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") ErrorWithComplexArgsParameters parameters) { + super(errorCode, errorName, errorInstanceId, parameters); + } + + public SerializableError toSerializableError() { + return SerializableError.builder() + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()) + .putParameters( + "stringExample", Objects.toString(errorParameters().stringExample())) + .putParameters("primitive", Objects.toString(errorParameters().primitive)) + .putParameters( + "collectionExample", + Objects.toString(errorParameters().collectionExample())) + .putParameters( + "optionalExample", + Objects.toString( + errorParameters().optionalExample().get().isPresent() + ? errorParameters().optionalExample() + : Optional.empty())) + .putParameters( + "optionalCollectionExample", + Objects.toString(errorParameters().optionalCollectionExample())) + .putParameters( + "enumExample", Objects.toString(errorParameters().enumExample())) + .build(); + } + } + + public static final class ErrorWithComplexArgsException extends RemoteException { + private ErrorWithComplexArgsSerializableError error; + private int status; + + public ErrorWithComplexArgsException(ErrorWithComplexArgsSerializableError error, int status) { + super(error.toSerializableError(), status); + this.error = error; + this.status = status; + } + + public ErrorWithComplexArgsSerializableError error() { + return error; + } + } } diff --git a/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/OptionalCollectionExample.java b/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/OptionalCollectionExample.java new file mode 100644 index 000000000..75fbcc399 --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/OptionalCollectionExample.java @@ -0,0 +1,71 @@ +package errors.com.palantir.product; + +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonValue; +import com.palantir.logsafe.Preconditions; +import java.util.Map; +import java.util.Optional; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import javax.annotation.processing.Generated; + +@Generated("com.palantir.conjure.java.types.AliasGenerator") +public final class OptionalCollectionExample { + private static final OptionalCollectionExample EMPTY = new OptionalCollectionExample(); + + private final Optional> value; + + private int memoizedHashCode; + + private OptionalCollectionExample(@Nonnull Optional> value) { + this.value = Preconditions.checkNotNull(value, "value cannot be null"); + } + + private OptionalCollectionExample() { + this(Optional.empty()); + } + + @JsonValue + public Optional> get() { + return value; + } + + @Override + public String toString() { + return value.toString(); + } + + @Override + public boolean equals(@Nullable Object other) { + return this == other + || (other instanceof OptionalCollectionExample && equalTo((OptionalCollectionExample) other)); + } + + private boolean equalTo(OptionalCollectionExample other) { + if (this.memoizedHashCode != 0 + && other.memoizedHashCode != 0 + && this.memoizedHashCode != other.memoizedHashCode) { + return false; + } + return this.value.equals(other.value); + } + + @Override + public int hashCode() { + int result = memoizedHashCode; + if (result == 0) { + result = this.value.hashCode(); + memoizedHashCode = result; + } + return result; + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static OptionalCollectionExample of(@Nonnull Optional> value) { + return new OptionalCollectionExample(value); + } + + public static OptionalCollectionExample empty() { + return EMPTY; + } +} diff --git a/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/StringExample.java b/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/StringExample.java new file mode 100644 index 000000000..9cbceca31 --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/StringExample.java @@ -0,0 +1,112 @@ +package errors.com.palantir.product; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonSetter; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import com.google.errorprone.annotations.CheckReturnValue; +import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.SafeArg; +import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; +import java.util.ArrayList; +import java.util.List; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import javax.annotation.processing.Generated; + +@JsonDeserialize(builder = StringExample.Builder.class) +@Generated("com.palantir.conjure.java.types.BeanGenerator") +public final class StringExample { + private final String string; + + private StringExample(String string) { + validateFields(string); + this.string = string; + } + + @JsonProperty("string") + public String getString() { + return this.string; + } + + @Override + public boolean equals(@Nullable Object other) { + return this == other || (other instanceof StringExample && equalTo((StringExample) other)); + } + + private boolean equalTo(StringExample other) { + return this.string.equals(other.string); + } + + @Override + public int hashCode() { + return this.string.hashCode(); + } + + @Override + public String toString() { + return "StringExample{string: " + string + '}'; + } + + public static StringExample of(String string) { + return builder().string(string).build(); + } + + private static void validateFields(String string) { + List missingFields = null; + missingFields = addFieldIfMissing(missingFields, string, "string"); + if (missingFields != null) { + throw new SafeIllegalArgumentException( + "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); + } + } + + private static List addFieldIfMissing(List prev, Object fieldValue, String fieldName) { + List missingFields = prev; + if (fieldValue == null) { + if (missingFields == null) { + missingFields = new ArrayList<>(1); + } + missingFields.add(fieldName); + } + return missingFields; + } + + public static Builder builder() { + return new Builder(); + } + + @Generated("com.palantir.conjure.java.types.BeanBuilderGenerator") + @JsonIgnoreProperties(ignoreUnknown = true) + public static final class Builder { + boolean _buildInvoked; + + private String string; + + private Builder() {} + + public Builder from(StringExample other) { + checkNotBuilt(); + string(other.getString()); + return this; + } + + @JsonSetter("string") + public Builder string(@Nonnull String string) { + checkNotBuilt(); + this.string = Preconditions.checkNotNull(string, "string cannot be null"); + return this; + } + + @CheckReturnValue + public StringExample build() { + checkNotBuilt(); + this._buildInvoked = true; + return new StringExample(string); + } + + private void checkNotBuilt() { + Preconditions.checkState(!_buildInvoked, "Build has already been called"); + } + } +} diff --git a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/EteService.java b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/EteService.java index 6318aae44..d502ff1ef 100644 --- a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/EteService.java +++ b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/EteService.java @@ -211,6 +211,18 @@ String jsonErrorsHeader( @HeaderParam("Authorization") @NotNull AuthHeader authHeader, @HeaderParam("Accept-Conjure-Error-Parameter-Format") String headerParameter); + /** + * This endpoint is used to test that that error parameters serialized as JSON or using Objects.toString + * are both handled correctly by the clients that return "rich" exceptions (which are sub-types of + * RemoteException). + */ + @GET + @Path("base/errors/serialization") + @ClientEndpoint(method = "GET", path = "/base/errors/serialization") + String errorParameterSerialization( + @HeaderParam("Authorization") @NotNull AuthHeader authHeader, + @HeaderParam("Accept-Conjure-Error-Parameter-Format") String headerParameter); + @GET @Path("base/alias-long") @ClientEndpoint(method = "GET", path = "/base/alias-long") diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EteServiceEndpoints.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EteServiceEndpoints.java index bd186ef1f..95cf24d0b 100644 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EteServiceEndpoints.java +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EteServiceEndpoints.java @@ -73,6 +73,7 @@ public List endpoints(UndertowRuntime runtime) { new OptionalEnumQueryEndpoint(runtime, delegate), new EnumHeaderEndpoint(runtime, delegate), new JsonErrorsHeaderEndpoint(runtime, delegate), + new ErrorParameterSerializationEndpoint(runtime, delegate), new AliasLongEndpointEndpoint(runtime, delegate), new ComplexQueryParametersEndpoint(runtime, delegate), new ReceiveListOfOptionalsEndpoint(runtime, delegate), @@ -1424,6 +1425,55 @@ public HttpHandler handler() { } } + private static final class ErrorParameterSerializationEndpoint implements HttpHandler, Endpoint { + private final UndertowRuntime runtime; + + private final UndertowEteService delegate; + + private final Serializer serializer; + + ErrorParameterSerializationEndpoint(UndertowRuntime runtime, UndertowEteService delegate) { + this.runtime = runtime; + this.delegate = delegate; + this.serializer = runtime.bodySerDe().serializer(new TypeMarker() {}, this); + } + + @Override + public void handleRequest(HttpServerExchange exchange) throws IOException { + AuthHeader authHeader = runtime.auth().header(exchange); + HeaderMap headerParams = exchange.getRequestHeaders(); + String headerParameter = + runtime.plainSerDe().deserializeString(headerParams.get("Accept-Conjure-Error-Parameter-Format")); + String result = delegate.errorParameterSerialization(authHeader, headerParameter); + serializer.serialize(result, exchange); + } + + @Override + public HttpString method() { + return Methods.GET; + } + + @Override + public String template() { + return "/base/errors/serialization"; + } + + @Override + public String serviceName() { + return "EteService"; + } + + @Override + public String name() { + return "errorParameterSerialization"; + } + + @Override + public HttpHandler handler() { + return this; + } + } + private static final class AliasLongEndpointEndpoint implements HttpHandler, Endpoint { private final UndertowRuntime runtime; diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/UndertowEteService.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/UndertowEteService.java index b1afb0f92..380029e20 100644 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/UndertowEteService.java +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/UndertowEteService.java @@ -124,6 +124,15 @@ Optional optionalQueryExter */ String jsonErrorsHeader(AuthHeader authHeader, String headerParameter); + /** + * This endpoint is used to test that that error parameters serialized as JSON or using Objects.toString + * are both handled correctly by the clients that return "rich" exceptions (which are sub-types of + * RemoteException). + * + * @apiNote {@code GET /base/errors/serialization} + */ + String errorParameterSerialization(AuthHeader authHeader, String headerParameter); + /** @apiNote {@code GET /base/alias-long} */ Optional aliasLongEndpoint(AuthHeader authHeader, Optional input); diff --git a/conjure-java-core/src/test/java/com/palantir/conjure/java/JerseyEteResource.java b/conjure-java-core/src/test/java/com/palantir/conjure/java/JerseyEteResource.java index 6e801f0c0..5810db419 100644 --- a/conjure-java-core/src/test/java/com/palantir/conjure/java/JerseyEteResource.java +++ b/conjure-java-core/src/test/java/com/palantir/conjure/java/JerseyEteResource.java @@ -179,6 +179,12 @@ public String jsonErrorsHeader(AuthHeader authHeader, String _headerParameter) { return "hello!"; } + @Override + public String errorParameterSerialization(AuthHeader authHeader, String headerParameter) { + // Conjure-Java has not supported Jersey for a while. We are not testing the error serialization feature here. + return "hello!"; + } + @Override public Optional aliasLongEndpoint(AuthHeader _authHeader, Optional input) { return input; diff --git a/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowEteResource.java b/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowEteResource.java index 6dfbd2707..e6867c1fd 100644 --- a/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowEteResource.java +++ b/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowEteResource.java @@ -21,7 +21,12 @@ import com.palantir.ri.ResourceIdentifier; import com.palantir.tokens.auth.AuthHeader; import com.palantir.tokens.auth.BearerToken; +import errors.com.palantir.product.CollectionExample; import errors.com.palantir.product.ConjureErrors; +import errors.com.palantir.product.EnumExample; +import errors.com.palantir.product.OptionalCollectionExample; +import errors.com.palantir.product.OptionalExample; +import errors.com.palantir.product.StringExample; import jakarta.validation.constraints.NotNull; import jakarta.ws.rs.core.StreamingOutput; import java.nio.charset.StandardCharsets; @@ -30,6 +35,7 @@ import java.time.ZoneId; import java.time.ZoneOffset; import java.util.List; +import java.util.Map; import java.util.Optional; import java.util.Set; import undertow.com.palantir.product.LongAlias; @@ -178,6 +184,21 @@ public String jsonErrorsHeader(AuthHeader authHeader, String headerParameter) { throw ConjureErrors.invalidServiceDefinition("my-service-string", Optional.of(SimpleEnum.VALUE)); } + @Override + public String errorParameterSerialization(AuthHeader authHeader, String headerParameter) { + if (headerParameter.equals("JSON") || headerParameter.equals("TOSTRING")) { + throw ConjureErrors.errorWithComplexArgs( + StringExample.of("string-example"), + 123L, + CollectionExample.of( + List.of("foo", "bar"), Map.of("foo", StringExample.of("bar")), Set.of("foo", "bar")), + OptionalExample.empty(), + OptionalCollectionExample.of(Optional.of(Map.of("foo", StringExample.of("bar")))), + EnumExample.A); + } + return "hello!"; + } + @Override public Optional aliasLongEndpoint(AuthHeader _authHeader, Optional input) { return input; diff --git a/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowServiceEteTest.java b/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowServiceEteTest.java index 92d317a6f..00be2ee36 100644 --- a/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowServiceEteTest.java +++ b/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowServiceEteTest.java @@ -565,6 +565,53 @@ public void testErrorParametersSerializedAsJson() { } } + @Test + public void test_json_parameter_errors() { + // Get the parameters when we use TOSTRING serialization + Map toStringParams; + Map jsonParams; + try { + client.errorParameterSerialization(AuthHeader.valueOf("authHeader"), "TOSTRING"); + } catch (RemoteException e) { + toStringParams = e.getError().parameters(); + assertThat(toStringParams) + .containsExactlyInAnyOrderEntriesOf(Map.of( + "stringExample", + "StringExample{string: string-example}", + "primitive", + "123", + "collectionExample", + "CollectionExample{strings: [foo, bar], map: {foo=StringExample{string: bar}}, set: [foo, bar]}", + "optionalExample", + "Optional.empty", + "optionalCollectionExample", + "Optional[{foo=StringExample{string: bar}}]", + "enumExample", + "A")); + } + + // Get the parameters when we use JSON serialization + try { + client.errorParameterSerialization(AuthHeader.valueOf("authHeader"), "JSON"); + } catch (RemoteException e) { + jsonParams = e.getError().parameters(); + assertThat(jsonParams) + .containsExactlyInAnyOrderEntriesOf(Map.of( + "stringExample", + "StringExample{string: string-example}", + "primitive", + "123", + "collectionExample", + "CollectionExample{strings: [foo, bar], map: {foo=StringExample{string: bar}}, set: [foo, bar]}", + "optionalExample", + "null", + "optionalCollectionExample", + "Optional[{foo={string=bar}}]", + "enumExample", + "A")); + } + } + private static HttpURLConnection openConnectionToTestApi(String path) throws IOException { URL url = new URL("http://localhost:" + port + "/test-example/api" + path); return (HttpURLConnection) url.openConnection(); diff --git a/conjure-java-core/src/test/java/com/palantir/conjure/java/parameterized/ParameterizedConjureGenerationTest.java b/conjure-java-core/src/test/java/com/palantir/conjure/java/parameterized/ParameterizedConjureGenerationTest.java index 82dfe465d..cc63df9fc 100644 --- a/conjure-java-core/src/test/java/com/palantir/conjure/java/parameterized/ParameterizedConjureGenerationTest.java +++ b/conjure-java-core/src/test/java/com/palantir/conjure/java/parameterized/ParameterizedConjureGenerationTest.java @@ -33,6 +33,7 @@ import java.util.Set; import java.util.stream.Collectors; import java.util.stream.Stream; +import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.MethodOrderer; import org.junit.jupiter.api.Order; import org.junit.jupiter.api.Test; @@ -50,7 +51,26 @@ public final class ParameterizedConjureGenerationTest { public File tempDir; private static List getTestCases() { - return TestCases.get(); +// return List.of(ParameterizedTestCase.builder() +// .name("errors") +// .docs("Testing error generation.") +// .files(Path.of("example-errors.yml")) +// .files(Path.of("example-errors-other.yml")) +// .files(Path.of("ete-service.yml")) +// .options(Options.builder() +// .undertowServicePrefix(true) +// .useImmutableBytes(true) +// .excludeEmptyOptionals(true) +// .jetbrainsContractAnnotations(true) +// .build()) +// .generatorTypes(List.of( +// GeneratorType.ERROR, +// GeneratorType.OBJECT, +// GeneratorType.UNDERTOW, +// GeneratorType.DIALOGUE, +// GeneratorType.ENDPOINT_ERROR)) +// .build()); + return TestCases.get(); } @ParameterizedTest @@ -68,6 +88,7 @@ void testGeneratedCode(ParameterizedTestCase testCase) throws IOException { @Test @Order(2) + @Disabled void validateOnlyRegisteredPackagesPresent() { File referenceFilesFolder = new File(REFERENCE_FILES_FOLDER); File[] files = referenceFilesFolder.listFiles(); diff --git a/conjure-java-core/src/test/resources/ete-service.yml b/conjure-java-core/src/test/resources/ete-service.yml index 0fe520283..9f82a7ff7 100644 --- a/conjure-java-core/src/test/resources/ete-service.yml +++ b/conjure-java-core/src/test/resources/ete-service.yml @@ -217,6 +217,18 @@ services: type: string returns: string + errorParameterSerialization: + http: GET /errors/serialization + docs: | + This endpoint is used to test that that error parameters serialized as JSON or using `Objects.toString` are + both handled correctly by the clients that return "rich" exceptions (which are sub-types of `RemoteException`). + args: + headerParameter: + param-type: header + param-id: Accept-Conjure-Error-Parameter-Format + type: string + returns: string + aliasLongEndpoint: http: GET /alias-long args: diff --git a/versions.lock b/versions.lock index b9ebe3409..c1f69fbf1 100644 --- a/versions.lock +++ b/versions.lock @@ -50,29 +50,29 @@ com.palantir.conjure.java.api:service-config:2.64.0 (6 constraints: 3466fcd7) com.palantir.conjure.java.api:ssl-config:2.64.0 (5 constraints: b44fa72d) -com.palantir.conjure.java.runtime:client-config:8.24.0 (6 constraints: ae6b4e29) +com.palantir.conjure.java.runtime:client-config:8.24.0 (6 constraints: ab6bbb28) com.palantir.conjure.java.runtime:conjure-java-jackson-optimizations:8.24.0 (1 constraints: 841cc4a4) -com.palantir.conjure.java.runtime:conjure-java-jackson-serialization:8.24.0 (4 constraints: 2c4acb1e) +com.palantir.conjure.java.runtime:conjure-java-jackson-serialization:8.24.0 (4 constraints: 2b4ac81e) -com.palantir.conjure.java.runtime:keystores:8.24.0 (3 constraints: 172ac85d) +com.palantir.conjure.java.runtime:keystores:8.24.0 (3 constraints: 162ac55d) com.palantir.deadlines:deadlines:0.15.0 (2 constraints: 9f1404ac) -com.palantir.dialogue:dialogue-apache-hc5-client:6.8.0 (2 constraints: 1b2977b6) +com.palantir.dialogue:dialogue-apache-hc5-client:6.7.0 (2 constraints: 1a2974b6) -com.palantir.dialogue:dialogue-blocking-channels:6.8.0 (2 constraints: 7b235c73) +com.palantir.dialogue:dialogue-blocking-channels:6.7.0 (2 constraints: 79232973) -com.palantir.dialogue:dialogue-clients:6.8.0 (1 constraints: 10052136) +com.palantir.dialogue:dialogue-clients:6.7.0 (1 constraints: 30088985) -com.palantir.dialogue:dialogue-core:6.8.0 (3 constraints: ec3c9a41) +com.palantir.dialogue:dialogue-core:6.7.0 (3 constraints: ea3c6541) -com.palantir.dialogue:dialogue-futures:6.8.0 (3 constraints: 41333839) +com.palantir.dialogue:dialogue-futures:6.7.0 (3 constraints: 3e33a938) -com.palantir.dialogue:dialogue-serde:6.8.0 (3 constraints: 2a2e8232) +com.palantir.dialogue:dialogue-serde:6.7.0 (3 constraints: 493156e9) -com.palantir.dialogue:dialogue-target:6.8.0 (7 constraints: d777644e) +com.palantir.dialogue:dialogue-target:6.7.0 (7 constraints: f27a7e9a) com.palantir.goethe:goethe:0.16.0 (1 constraints: 3905353b) diff --git a/versions.props b/versions.props index 347cb6cf8..6ff331ba6 100644 --- a/versions.props +++ b/versions.props @@ -11,8 +11,8 @@ com.palantir.conjure.java.runtime:* = 8.24.0 com.palantir.conjure.verification:* = 0.19.0 com.palantir.conjure:* = 4.50.0 com.palantir.deadlines:* = 0.15.0 -com.palantir.dialogue:* = 6.8.0 com.palantir.goethe:* = 0.16.0 +com.palantir.dialogue:* = 6.2.0-18-ge483b3c com.palantir.human-readable-types:* = 1.7.0 com.palantir.javapoet:javapoet = 0.7.0 com.palantir.ri:resource-identifier = 2.11.0 From 6e323616e296e5086f1638b22f1a2053f57458dc Mon Sep 17 00:00:00 2001 From: Pritham Marupaka Date: Mon, 4 Aug 2025 23:55:00 -0400 Subject: [PATCH 07/26] wip code-gen --- .../palantir/product/EteServiceBlocking.java | 6 +- .../another/EndpointSpecificErrors.java | 64 +++++ .../com/palantir/product/ConjureErrors.java | 70 ++++++ .../product/EndpointSpecificErrors.java | 69 ++++++ .../product/EndpointSpecificTwoErrors.java | 64 +++++ .../com/palantir/product/TestErrors.java | 166 +++++++++++++ .../com/palantir/another/ConjureErrors.java | 43 ++++ .../another/ConjureJavaOtherErrors.java | 43 ++++ .../com/palantir/product/ConjureErrors.java | 234 ++++++++++++++++-- .../palantir/product/ConjureJavaErrors.java | 43 ++++ .../product/OptionalCollectionExample.java | 71 ------ .../com/palantir/product/StringAlias.java | 58 +++++ .../com/palantir/product/StringExample.java | 112 --------- .../another/EndpointSpecificErrors.java | 43 ++++ .../com/palantir/product/ConjureErrors.java | 47 ++++ .../product/EndpointSpecificErrors.java | 48 ++++ .../product/EndpointSpecificTwoErrors.java | 43 ++++ .../com/palantir/product/TestErrors.java | 129 ++++++++++ .../conjure/java/types/ErrorGenerator.java | 157 +++++++++++- .../java/util/ErrorGenerationUtils.java | 15 ++ .../conjure/java/UndertowEteResource.java | 119 ++++++++- .../conjure/java/UndertowServiceEteTest.java | 35 +-- .../ParameterizedConjureGenerationTest.java | 40 +-- versions.lock | 22 +- versions.props | 2 +- 25 files changed, 1469 insertions(+), 274 deletions(-) create mode 100644 conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/another/EndpointSpecificErrors.java create mode 100644 conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ConjureErrors.java create mode 100644 conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/EndpointSpecificErrors.java create mode 100644 conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/EndpointSpecificTwoErrors.java create mode 100644 conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/TestErrors.java delete mode 100644 conjure-java-core/src/integrationInput/java/errors/com/palantir/product/OptionalCollectionExample.java create mode 100644 conjure-java-core/src/integrationInput/java/errors/com/palantir/product/StringAlias.java delete mode 100644 conjure-java-core/src/integrationInput/java/errors/com/palantir/product/StringExample.java diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceBlocking.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceBlocking.java index 3d670d2b9..8bf3fc689 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceBlocking.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceBlocking.java @@ -387,14 +387,14 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con private final EndpointChannel errorParameterSerializationChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.errorParameterSerialization); - private final Deserializer errorParameterSerializationDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() + private final Deserializer errorParameterSerializationDeserializer = + _runtime.bodySerDe().deserializer(DeserializerArgs.builder() .baseType(new TypeMarker() {}) .success(new TypeMarker() {}) .exception( ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), new TypeMarker() {}, - new TypeMarker() {}) + new TypeMarker(){}) .build()); private final EndpointChannel aliasLongEndpointChannel = diff --git a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/another/EndpointSpecificErrors.java b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/another/EndpointSpecificErrors.java new file mode 100644 index 000000000..e59dc9bdd --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/another/EndpointSpecificErrors.java @@ -0,0 +1,64 @@ +package dialogueendpointresulttypes.com.palantir.another; + +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.palantir.conjure.java.api.errors.AbstractSerializableError; +import com.palantir.conjure.java.api.errors.ErrorType; +import com.palantir.conjure.java.api.errors.RemoteException; +import com.palantir.conjure.java.api.errors.SerializableError; +import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.Safe; +import javax.annotation.processing.Generated; + +@Generated("com.palantir.conjure.java.types.ErrorGenerator") +public final class EndpointSpecificErrors { + /** An error in a different package. */ + public static final ErrorType DIFFERENT_PACKAGE = + ErrorType.create(ErrorType.Code.INTERNAL, "EndpointSpecific:DifferentPackage"); + + private EndpointSpecificErrors() {} + + /** Returns true if the {@link RemoteException} is named EndpointSpecific:DifferentPackage */ + public static boolean isDifferentPackage(RemoteException remoteException) { + Preconditions.checkNotNull(remoteException, "remote exception must not be null"); + return DIFFERENT_PACKAGE.name().equals(remoteException.getError().errorName()); + } + + public static record DifferentPackageParameters() {} + + public static final class DifferentPackageSerializableError + extends AbstractSerializableError { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + DifferentPackageSerializableError( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorName") @Safe String errorName, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") DifferentPackageParameters parameters) { + super(errorCode, errorName, errorInstanceId, parameters); + } + + public SerializableError toSerializableError() { + SerializableError.Builder builder = SerializableError.builder() + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()); + return builder.build(); + } + } + + public static final class DifferentPackageException extends RemoteException { + private DifferentPackageSerializableError error; + + private int status; + + public DifferentPackageException(DifferentPackageSerializableError error, int status) { + super(error.toSerializableError(), status); + this.error = error; + this.status = status; + } + + public DifferentPackageSerializableError error() { + return error; + } + } +} diff --git a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ConjureErrors.java b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ConjureErrors.java new file mode 100644 index 000000000..052aefcba --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ConjureErrors.java @@ -0,0 +1,70 @@ +package dialogueendpointresulttypes.com.palantir.product; + +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.palantir.conjure.java.api.errors.AbstractSerializableError; +import com.palantir.conjure.java.api.errors.ErrorType; +import com.palantir.conjure.java.api.errors.RemoteException; +import com.palantir.conjure.java.api.errors.SerializableError; +import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.Safe; +import java.util.Objects; +import javax.annotation.processing.Generated; + +@Generated("com.palantir.conjure.java.types.ErrorGenerator") +public final class ConjureErrors { + /** Cause argument conflicts with reserved Throwable cause parameter. */ + public static final ErrorType CONFLICTING_CAUSE_SAFE_ARG = + ErrorType.create(ErrorType.Code.INTERNAL, "Conjure:ConflictingCauseSafeArg"); + + private ConjureErrors() {} + + /** Returns true if the {@link RemoteException} is named Conjure:ConflictingCauseSafeArg */ + public static boolean isConflictingCauseSafeArg(RemoteException remoteException) { + Preconditions.checkNotNull(remoteException, "remote exception must not be null"); + return CONFLICTING_CAUSE_SAFE_ARG + .name() + .equals(remoteException.getError().errorName()); + } + + public static record ConflictingCauseSafeArgParameters( + @JsonProperty("cause") @Safe String cause_, @JsonProperty("shouldThrow") @Safe boolean shouldThrow_) {} + + public static final class ConflictingCauseSafeArgSerializableError + extends AbstractSerializableError { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + ConflictingCauseSafeArgSerializableError( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorName") @Safe String errorName, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") ConflictingCauseSafeArgParameters parameters) { + super(errorCode, errorName, errorInstanceId, parameters); + } + + public SerializableError toSerializableError() { + SerializableError.Builder builder = SerializableError.builder() + .putParameters("cause", Objects.toString(parameters().cause_())) + .putParameters("shouldThrow", Objects.toString(parameters().shouldThrow_())) + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()); + return builder.build(); + } + } + + public static final class ConflictingCauseSafeArgException extends RemoteException { + private ConflictingCauseSafeArgSerializableError error; + + private int status; + + public ConflictingCauseSafeArgException(ConflictingCauseSafeArgSerializableError error, int status) { + super(error.toSerializableError(), status); + this.error = error; + this.status = status; + } + + public ConflictingCauseSafeArgSerializableError error() { + return error; + } + } +} diff --git a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/EndpointSpecificErrors.java b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/EndpointSpecificErrors.java new file mode 100644 index 000000000..96446fdce --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/EndpointSpecificErrors.java @@ -0,0 +1,69 @@ +package dialogueendpointresulttypes.com.palantir.product; + +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.palantir.conjure.java.api.errors.AbstractSerializableError; +import com.palantir.conjure.java.api.errors.ErrorType; +import com.palantir.conjure.java.api.errors.RemoteException; +import com.palantir.conjure.java.api.errors.SerializableError; +import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.Safe; +import com.palantir.logsafe.Unsafe; +import java.util.Objects; +import javax.annotation.processing.Generated; + +@Generated("com.palantir.conjure.java.types.ErrorGenerator") +public final class EndpointSpecificErrors { + /** Docs for an endpoint error. */ + public static final ErrorType ENDPOINT_ERROR = + ErrorType.create(ErrorType.Code.INVALID_ARGUMENT, "EndpointSpecific:EndpointError"); + + private EndpointSpecificErrors() {} + + /** Returns true if the {@link RemoteException} is named EndpointSpecific:EndpointError */ + public static boolean isEndpointError(RemoteException remoteException) { + Preconditions.checkNotNull(remoteException, "remote exception must not be null"); + return ENDPOINT_ERROR.name().equals(remoteException.getError().errorName()); + } + + public static record EndpointErrorParameters( + @JsonProperty("typeName") @Safe String typeName, @JsonProperty("typeDef") @Unsafe Object typeDef) {} + + public static final class EndpointErrorSerializableError + extends AbstractSerializableError { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + EndpointErrorSerializableError( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorName") @Safe String errorName, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") EndpointErrorParameters parameters) { + super(errorCode, errorName, errorInstanceId, parameters); + } + + public SerializableError toSerializableError() { + SerializableError.Builder builder = SerializableError.builder() + .putParameters("typeName", Objects.toString(parameters().typeName())) + .putParameters("typeDef", Objects.toString(parameters().typeDef())) + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()); + return builder.build(); + } + } + + public static final class EndpointErrorException extends RemoteException { + private EndpointErrorSerializableError error; + + private int status; + + public EndpointErrorException(EndpointErrorSerializableError error, int status) { + super(error.toSerializableError(), status); + this.error = error; + this.status = status; + } + + public EndpointErrorSerializableError error() { + return error; + } + } +} diff --git a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/EndpointSpecificTwoErrors.java b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/EndpointSpecificTwoErrors.java new file mode 100644 index 000000000..c25be2c9a --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/EndpointSpecificTwoErrors.java @@ -0,0 +1,64 @@ +package dialogueendpointresulttypes.com.palantir.product; + +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.palantir.conjure.java.api.errors.AbstractSerializableError; +import com.palantir.conjure.java.api.errors.ErrorType; +import com.palantir.conjure.java.api.errors.RemoteException; +import com.palantir.conjure.java.api.errors.SerializableError; +import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.Safe; +import javax.annotation.processing.Generated; + +@Generated("com.palantir.conjure.java.types.ErrorGenerator") +public final class EndpointSpecificTwoErrors { + /** An error in a different namespace. */ + public static final ErrorType DIFFERENT_NAMESPACE = + ErrorType.create(ErrorType.Code.INTERNAL, "EndpointSpecificTwo:DifferentNamespace"); + + private EndpointSpecificTwoErrors() {} + + /** Returns true if the {@link RemoteException} is named EndpointSpecificTwo:DifferentNamespace */ + public static boolean isDifferentNamespace(RemoteException remoteException) { + Preconditions.checkNotNull(remoteException, "remote exception must not be null"); + return DIFFERENT_NAMESPACE.name().equals(remoteException.getError().errorName()); + } + + public static record DifferentNamespaceParameters() {} + + public static final class DifferentNamespaceSerializableError + extends AbstractSerializableError { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + DifferentNamespaceSerializableError( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorName") @Safe String errorName, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") DifferentNamespaceParameters parameters) { + super(errorCode, errorName, errorInstanceId, parameters); + } + + public SerializableError toSerializableError() { + SerializableError.Builder builder = SerializableError.builder() + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()); + return builder.build(); + } + } + + public static final class DifferentNamespaceException extends RemoteException { + private DifferentNamespaceSerializableError error; + + private int status; + + public DifferentNamespaceException(DifferentNamespaceSerializableError error, int status) { + super(error.toSerializableError(), status); + this.error = error; + this.status = status; + } + + public DifferentNamespaceSerializableError error() { + return error; + } + } +} diff --git a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/TestErrors.java b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/TestErrors.java new file mode 100644 index 000000000..0238affd0 --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/TestErrors.java @@ -0,0 +1,166 @@ +package dialogueendpointresulttypes.com.palantir.product; + +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.palantir.conjure.java.api.errors.AbstractSerializableError; +import com.palantir.conjure.java.api.errors.ErrorType; +import com.palantir.conjure.java.api.errors.RemoteException; +import com.palantir.conjure.java.api.errors.SerializableError; +import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.Safe; +import com.palantir.logsafe.Unsafe; +import java.util.Map; +import java.util.Objects; +import javax.annotation.processing.Generated; + +@Generated("com.palantir.conjure.java.types.ErrorGenerator") +public final class TestErrors { + public static final ErrorType COMPLICATED_PARAMETERS = + ErrorType.create(ErrorType.Code.INTERNAL, "Test:ComplicatedParameters"); + + public static final ErrorType INVALID_ARGUMENT = + ErrorType.create(ErrorType.Code.INVALID_ARGUMENT, "Test:InvalidArgument"); + + public static final ErrorType NOT_FOUND = ErrorType.create(ErrorType.Code.NOT_FOUND, "Test:NotFound"); + + private TestErrors() {} + + /** Returns true if the {@link RemoteException} is named Test:ComplicatedParameters */ + public static boolean isComplicatedParameters(RemoteException remoteException) { + Preconditions.checkNotNull(remoteException, "remote exception must not be null"); + return COMPLICATED_PARAMETERS.name().equals(remoteException.getError().errorName()); + } + + /** Returns true if the {@link RemoteException} is named Test:InvalidArgument */ + public static boolean isInvalidArgument(RemoteException remoteException) { + Preconditions.checkNotNull(remoteException, "remote exception must not be null"); + return INVALID_ARGUMENT.name().equals(remoteException.getError().errorName()); + } + + /** Returns true if the {@link RemoteException} is named Test:NotFound */ + public static boolean isNotFound(RemoteException remoteException) { + Preconditions.checkNotNull(remoteException, "remote exception must not be null"); + return NOT_FOUND.name().equals(remoteException.getError().errorName()); + } + + public static record ComplicatedParametersParameters( + @JsonProperty("complicatedObjectMap") @Safe Map complicatedObjectMap) {} + + public static record InvalidArgumentParameters( + @JsonProperty("field") @Safe String field, @JsonProperty("value") @Unsafe String value) {} + + public static record NotFoundParameters(@JsonProperty("resource") @Safe String resource) {} + + public static final class ComplicatedParametersSerializableError + extends AbstractSerializableError { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + ComplicatedParametersSerializableError( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorName") @Safe String errorName, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") ComplicatedParametersParameters parameters) { + super(errorCode, errorName, errorInstanceId, parameters); + } + + public SerializableError toSerializableError() { + SerializableError.Builder builder = SerializableError.builder() + .putParameters( + "complicatedObjectMap", + Objects.toString(parameters().complicatedObjectMap())) + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()); + return builder.build(); + } + } + + public static final class InvalidArgumentSerializableError + extends AbstractSerializableError { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + InvalidArgumentSerializableError( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorName") @Safe String errorName, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") InvalidArgumentParameters parameters) { + super(errorCode, errorName, errorInstanceId, parameters); + } + + public SerializableError toSerializableError() { + SerializableError.Builder builder = SerializableError.builder() + .putParameters("field", Objects.toString(parameters().field())) + .putParameters("value", Objects.toString(parameters().value())) + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()); + return builder.build(); + } + } + + public static final class NotFoundSerializableError extends AbstractSerializableError { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + NotFoundSerializableError( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorName") @Safe String errorName, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") NotFoundParameters parameters) { + super(errorCode, errorName, errorInstanceId, parameters); + } + + public SerializableError toSerializableError() { + SerializableError.Builder builder = SerializableError.builder() + .putParameters("resource", Objects.toString(parameters().resource())) + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()); + return builder.build(); + } + } + + public static final class ComplicatedParametersException extends RemoteException { + private ComplicatedParametersSerializableError error; + + private int status; + + public ComplicatedParametersException(ComplicatedParametersSerializableError error, int status) { + super(error.toSerializableError(), status); + this.error = error; + this.status = status; + } + + public ComplicatedParametersSerializableError error() { + return error; + } + } + + public static final class InvalidArgumentException extends RemoteException { + private InvalidArgumentSerializableError error; + + private int status; + + public InvalidArgumentException(InvalidArgumentSerializableError error, int status) { + super(error.toSerializableError(), status); + this.error = error; + this.status = status; + } + + public InvalidArgumentSerializableError error() { + return error; + } + } + + public static final class NotFoundException extends RemoteException { + private NotFoundSerializableError error; + + private int status; + + public NotFoundException(NotFoundSerializableError error, int status) { + super(error.toSerializableError(), status); + this.error = error; + this.status = status; + } + + public NotFoundSerializableError error() { + return error; + } + } +} diff --git a/conjure-java-core/src/integrationInput/java/errors/com/palantir/another/ConjureErrors.java b/conjure-java-core/src/integrationInput/java/errors/com/palantir/another/ConjureErrors.java index c106c2f1d..92219a91d 100644 --- a/conjure-java-core/src/integrationInput/java/errors/com/palantir/another/ConjureErrors.java +++ b/conjure-java-core/src/integrationInput/java/errors/com/palantir/another/ConjureErrors.java @@ -1,9 +1,14 @@ package errors.com.palantir.another; +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.palantir.conjure.java.api.errors.AbstractSerializableError; import com.palantir.conjure.java.api.errors.ErrorType; import com.palantir.conjure.java.api.errors.RemoteException; +import com.palantir.conjure.java.api.errors.SerializableError; import com.palantir.conjure.java.api.errors.ServiceException; import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.Safe; import javax.annotation.Nullable; import javax.annotation.processing.Generated; import org.jetbrains.annotations.Contract; @@ -41,4 +46,42 @@ public static boolean isDifferentPackageError(RemoteException remoteException) { Preconditions.checkNotNull(remoteException, "remote exception must not be null"); return DIFFERENT_PACKAGE_ERROR.name().equals(remoteException.getError().errorName()); } + + public static record DifferentPackageParameters() {} + + public static final class DifferentPackageSerializableError + extends AbstractSerializableError { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + DifferentPackageSerializableError( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorName") @Safe String errorName, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") DifferentPackageParameters parameters) { + super(errorCode, errorName, errorInstanceId, parameters); + } + + public SerializableError toSerializableError() { + SerializableError.Builder builder = SerializableError.builder() + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()); + return builder.build(); + } + } + + public static final class DifferentPackageException extends RemoteException { + private DifferentPackageSerializableError error; + + private int status; + + public DifferentPackageException(DifferentPackageSerializableError error, int status) { + super(error.toSerializableError(), status); + this.error = error; + this.status = status; + } + + public DifferentPackageSerializableError error() { + return error; + } + } } diff --git a/conjure-java-core/src/integrationInput/java/errors/com/palantir/another/ConjureJavaOtherErrors.java b/conjure-java-core/src/integrationInput/java/errors/com/palantir/another/ConjureJavaOtherErrors.java index 01dacd9c0..49f9e4398 100644 --- a/conjure-java-core/src/integrationInput/java/errors/com/palantir/another/ConjureJavaOtherErrors.java +++ b/conjure-java-core/src/integrationInput/java/errors/com/palantir/another/ConjureJavaOtherErrors.java @@ -1,9 +1,14 @@ package errors.com.palantir.another; +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.palantir.conjure.java.api.errors.AbstractSerializableError; import com.palantir.conjure.java.api.errors.ErrorType; import com.palantir.conjure.java.api.errors.RemoteException; +import com.palantir.conjure.java.api.errors.SerializableError; import com.palantir.conjure.java.api.errors.ServiceException; import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.Safe; import javax.annotation.Nullable; import javax.annotation.processing.Generated; import org.jetbrains.annotations.Contract; @@ -41,4 +46,42 @@ public static boolean isJavaCompilationFailed(RemoteException remoteException) { Preconditions.checkNotNull(remoteException, "remote exception must not be null"); return JAVA_COMPILATION_FAILED.name().equals(remoteException.getError().errorName()); } + + public static record JavaCompilationFailedParameters() {} + + public static final class JavaCompilationFailedSerializableError + extends AbstractSerializableError { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + JavaCompilationFailedSerializableError( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorName") @Safe String errorName, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") JavaCompilationFailedParameters parameters) { + super(errorCode, errorName, errorInstanceId, parameters); + } + + public SerializableError toSerializableError() { + SerializableError.Builder builder = SerializableError.builder() + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()); + return builder.build(); + } + } + + public static final class JavaCompilationFailedException extends RemoteException { + private JavaCompilationFailedSerializableError error; + + private int status; + + public JavaCompilationFailedException(JavaCompilationFailedSerializableError error, int status) { + super(error.toSerializableError(), status); + this.error = error; + this.status = status; + } + + public JavaCompilationFailedSerializableError error() { + return error; + } + } } diff --git a/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureErrors.java b/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureErrors.java index bbf2f2cc3..97c7ebf61 100644 --- a/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureErrors.java +++ b/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureErrors.java @@ -13,7 +13,6 @@ import com.palantir.logsafe.Unsafe; import com.palantir.logsafe.UnsafeArg; import java.util.Objects; -import java.util.Optional; import javax.annotation.Nullable; import javax.annotation.processing.Generated; import org.jetbrains.annotations.Contract; @@ -337,14 +336,84 @@ public static boolean isInvalidTypeDefinition(RemoteException remoteException) { return INVALID_TYPE_DEFINITION.name().equals(remoteException.getError().errorName()); } - // HAND-WRITTEN CODE BELOW + public static record ConflictingCauseSafeArgParameters( + @JsonProperty("cause") @Safe String cause_, @JsonProperty("shouldThrow") @Safe boolean shouldThrow_) {} + + public static record ConflictingCauseUnsafeArgParameters( + @JsonProperty("cause") @Unsafe String cause_, @JsonProperty("shouldThrow") @Unsafe boolean shouldThrow_) {} + public static record ErrorWithComplexArgsParameters( - @JsonProperty("stringExample") @Safe StringExample stringExample, - @JsonProperty("primitive") @Safe long primitive, + @JsonProperty("primitiveExample") @Safe PrimitiveExample primitiveExample, @JsonProperty("collectionExample") @Safe CollectionExample collectionExample, + @JsonProperty("nestedCollectionExample") @Safe NestedCollectionExample nestedCollectionExample, @JsonProperty("optionalExample") @Safe OptionalExample optionalExample, - @JsonProperty("optionalCollectionExample") @Safe OptionalCollectionExample optionalCollectionExample, - @JsonProperty("enumExample") @Safe EnumExample enumExample) {} + @JsonProperty("objectReference") @Safe ObjectReference objectReference, + @JsonProperty("unionExample") @Safe UnionExample unionExample, + @JsonProperty("enumExample") @Safe EnumExample enumExample, + @JsonProperty("stringAlias") @Safe StringAlias stringAlias, + @JsonProperty("optionalAlias") @Safe OptionalAlias optionalAlias, + @JsonProperty("collectionAlias") @Safe CollectionAlias collectionAlias, + @JsonProperty("nestedAlias") @Safe NestedAlias nestedAlias, + @JsonProperty("externalExample") @Safe ExternalExample externalExample, + @JsonProperty("anyExample") @Safe AnyExample anyExample, + @JsonProperty("emptyObject") @Safe EmptyObject emptyObject, + @JsonProperty("complexExample") @Safe ComplexExample complexExample, + @JsonProperty("safetyExample") @Unsafe SafetyExample safetyExample) {} + + /** + * @param serviceName Name of the invalid service definition. + * @param serviceDef Details of the invalid service definition. + */ + public static record InvalidServiceDefinitionParameters( + @JsonProperty("serviceName") @Safe String serviceName, + @JsonProperty("serviceDef") @Unsafe Object serviceDef) {} + + public static record InvalidTypeDefinitionParameters( + @JsonProperty("typeName") @Safe String typeName, @JsonProperty("typeDef") @Unsafe Object typeDef) {} + + public static final class ConflictingCauseSafeArgSerializableError + extends AbstractSerializableError { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + ConflictingCauseSafeArgSerializableError( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorName") @Safe String errorName, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") ConflictingCauseSafeArgParameters parameters) { + super(errorCode, errorName, errorInstanceId, parameters); + } + + public SerializableError toSerializableError() { + SerializableError.Builder builder = SerializableError.builder() + .putParameters("cause", Objects.toString(parameters().cause_())) + .putParameters("shouldThrow", Objects.toString(parameters().shouldThrow_())) + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()); + return builder.build(); + } + } + + public static final class ConflictingCauseUnsafeArgSerializableError + extends AbstractSerializableError { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + ConflictingCauseUnsafeArgSerializableError( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorName") @Safe String errorName, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") ConflictingCauseUnsafeArgParameters parameters) { + super(errorCode, errorName, errorInstanceId, parameters); + } + + public SerializableError toSerializableError() { + SerializableError.Builder builder = SerializableError.builder() + .putParameters("cause", Objects.toString(parameters().cause_())) + .putParameters("shouldThrow", Objects.toString(parameters().shouldThrow_())) + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()); + return builder.build(); + } + } public static final class ErrorWithComplexArgsSerializableError extends AbstractSerializableError { @@ -358,33 +427,120 @@ public static final class ErrorWithComplexArgsSerializableError } public SerializableError toSerializableError() { - return SerializableError.builder() - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()) + SerializableError.Builder builder = SerializableError.builder() + .putParameters( + "primitiveExample", Objects.toString(parameters().primitiveExample())) + .putParameters( + "collectionExample", Objects.toString(parameters().collectionExample())) .putParameters( - "stringExample", Objects.toString(errorParameters().stringExample())) - .putParameters("primitive", Objects.toString(errorParameters().primitive)) + "nestedCollectionExample", + Objects.toString(parameters().nestedCollectionExample())) .putParameters( - "collectionExample", - Objects.toString(errorParameters().collectionExample())) + "optionalExample", Objects.toString(parameters().optionalExample())) .putParameters( - "optionalExample", - Objects.toString( - errorParameters().optionalExample().get().isPresent() - ? errorParameters().optionalExample() - : Optional.empty())) + "objectReference", Objects.toString(parameters().objectReference())) + .putParameters("unionExample", Objects.toString(parameters().unionExample())) + .putParameters("enumExample", Objects.toString(parameters().enumExample())) + .putParameters("stringAlias", Objects.toString(parameters().stringAlias())) .putParameters( - "optionalCollectionExample", - Objects.toString(errorParameters().optionalCollectionExample())) + "optionalAlias", Objects.toString(parameters().optionalAlias())) .putParameters( - "enumExample", Objects.toString(errorParameters().enumExample())) - .build(); + "collectionAlias", Objects.toString(parameters().collectionAlias())) + .putParameters("nestedAlias", Objects.toString(parameters().nestedAlias())) + .putParameters( + "externalExample", Objects.toString(parameters().externalExample())) + .putParameters("anyExample", Objects.toString(parameters().anyExample())) + .putParameters("emptyObject", Objects.toString(parameters().emptyObject())) + .putParameters( + "complexExample", Objects.toString(parameters().complexExample())) + .putParameters( + "safetyExample", Objects.toString(parameters().safetyExample())) + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()); + return builder.build(); + } + } + + public static final class InvalidServiceDefinitionSerializableError + extends AbstractSerializableError { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + InvalidServiceDefinitionSerializableError( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorName") @Safe String errorName, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") InvalidServiceDefinitionParameters parameters) { + super(errorCode, errorName, errorInstanceId, parameters); + } + + public SerializableError toSerializableError() { + SerializableError.Builder builder = SerializableError.builder() + .putParameters("serviceName", Objects.toString(parameters().serviceName())) + .putParameters("serviceDef", Objects.toString(parameters().serviceDef())) + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()); + return builder.build(); + } + } + + public static final class InvalidTypeDefinitionSerializableError + extends AbstractSerializableError { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + InvalidTypeDefinitionSerializableError( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorName") @Safe String errorName, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") InvalidTypeDefinitionParameters parameters) { + super(errorCode, errorName, errorInstanceId, parameters); + } + + public SerializableError toSerializableError() { + SerializableError.Builder builder = SerializableError.builder() + .putParameters("typeName", Objects.toString(parameters().typeName())) + .putParameters("typeDef", Objects.toString(parameters().typeDef())) + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()); + return builder.build(); + } + } + + public static final class ConflictingCauseSafeArgException extends RemoteException { + private ConflictingCauseSafeArgSerializableError error; + + private int status; + + public ConflictingCauseSafeArgException(ConflictingCauseSafeArgSerializableError error, int status) { + super(error.toSerializableError(), status); + this.error = error; + this.status = status; + } + + public ConflictingCauseSafeArgSerializableError error() { + return error; + } + } + + public static final class ConflictingCauseUnsafeArgException extends RemoteException { + private ConflictingCauseUnsafeArgSerializableError error; + + private int status; + + public ConflictingCauseUnsafeArgException(ConflictingCauseUnsafeArgSerializableError error, int status) { + super(error.toSerializableError(), status); + this.error = error; + this.status = status; + } + + public ConflictingCauseUnsafeArgSerializableError error() { + return error; } } public static final class ErrorWithComplexArgsException extends RemoteException { private ErrorWithComplexArgsSerializableError error; + private int status; public ErrorWithComplexArgsException(ErrorWithComplexArgsSerializableError error, int status) { @@ -397,4 +553,36 @@ public ErrorWithComplexArgsSerializableError error() { return error; } } + + public static final class InvalidServiceDefinitionException extends RemoteException { + private InvalidServiceDefinitionSerializableError error; + + private int status; + + public InvalidServiceDefinitionException(InvalidServiceDefinitionSerializableError error, int status) { + super(error.toSerializableError(), status); + this.error = error; + this.status = status; + } + + public InvalidServiceDefinitionSerializableError error() { + return error; + } + } + + public static final class InvalidTypeDefinitionException extends RemoteException { + private InvalidTypeDefinitionSerializableError error; + + private int status; + + public InvalidTypeDefinitionException(InvalidTypeDefinitionSerializableError error, int status) { + super(error.toSerializableError(), status); + this.error = error; + this.status = status; + } + + public InvalidTypeDefinitionSerializableError error() { + return error; + } + } } diff --git a/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureJavaErrors.java b/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureJavaErrors.java index 32adada3c..0ad353c73 100644 --- a/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureJavaErrors.java +++ b/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureJavaErrors.java @@ -1,9 +1,14 @@ package errors.com.palantir.product; +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.palantir.conjure.java.api.errors.AbstractSerializableError; import com.palantir.conjure.java.api.errors.ErrorType; import com.palantir.conjure.java.api.errors.RemoteException; +import com.palantir.conjure.java.api.errors.SerializableError; import com.palantir.conjure.java.api.errors.ServiceException; import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.Safe; import javax.annotation.Nullable; import javax.annotation.processing.Generated; import org.jetbrains.annotations.Contract; @@ -41,4 +46,42 @@ public static boolean isJavaCompilationFailed(RemoteException remoteException) { Preconditions.checkNotNull(remoteException, "remote exception must not be null"); return JAVA_COMPILATION_FAILED.name().equals(remoteException.getError().errorName()); } + + public static record JavaCompilationFailedParameters() {} + + public static final class JavaCompilationFailedSerializableError + extends AbstractSerializableError { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + JavaCompilationFailedSerializableError( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorName") @Safe String errorName, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") JavaCompilationFailedParameters parameters) { + super(errorCode, errorName, errorInstanceId, parameters); + } + + public SerializableError toSerializableError() { + SerializableError.Builder builder = SerializableError.builder() + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()); + return builder.build(); + } + } + + public static final class JavaCompilationFailedException extends RemoteException { + private JavaCompilationFailedSerializableError error; + + private int status; + + public JavaCompilationFailedException(JavaCompilationFailedSerializableError error, int status) { + super(error.toSerializableError(), status); + this.error = error; + this.status = status; + } + + public JavaCompilationFailedSerializableError error() { + return error; + } + } } diff --git a/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/OptionalCollectionExample.java b/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/OptionalCollectionExample.java deleted file mode 100644 index 75fbcc399..000000000 --- a/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/OptionalCollectionExample.java +++ /dev/null @@ -1,71 +0,0 @@ -package errors.com.palantir.product; - -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonValue; -import com.palantir.logsafe.Preconditions; -import java.util.Map; -import java.util.Optional; -import javax.annotation.Nonnull; -import javax.annotation.Nullable; -import javax.annotation.processing.Generated; - -@Generated("com.palantir.conjure.java.types.AliasGenerator") -public final class OptionalCollectionExample { - private static final OptionalCollectionExample EMPTY = new OptionalCollectionExample(); - - private final Optional> value; - - private int memoizedHashCode; - - private OptionalCollectionExample(@Nonnull Optional> value) { - this.value = Preconditions.checkNotNull(value, "value cannot be null"); - } - - private OptionalCollectionExample() { - this(Optional.empty()); - } - - @JsonValue - public Optional> get() { - return value; - } - - @Override - public String toString() { - return value.toString(); - } - - @Override - public boolean equals(@Nullable Object other) { - return this == other - || (other instanceof OptionalCollectionExample && equalTo((OptionalCollectionExample) other)); - } - - private boolean equalTo(OptionalCollectionExample other) { - if (this.memoizedHashCode != 0 - && other.memoizedHashCode != 0 - && this.memoizedHashCode != other.memoizedHashCode) { - return false; - } - return this.value.equals(other.value); - } - - @Override - public int hashCode() { - int result = memoizedHashCode; - if (result == 0) { - result = this.value.hashCode(); - memoizedHashCode = result; - } - return result; - } - - @JsonCreator(mode = JsonCreator.Mode.DELEGATING) - public static OptionalCollectionExample of(@Nonnull Optional> value) { - return new OptionalCollectionExample(value); - } - - public static OptionalCollectionExample empty() { - return EMPTY; - } -} diff --git a/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/StringAlias.java b/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/StringAlias.java new file mode 100644 index 000000000..0eb940fc9 --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/StringAlias.java @@ -0,0 +1,58 @@ +package errors.com.palantir.product; + +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonValue; +import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.Safe; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import javax.annotation.processing.Generated; + +@Safe +@Generated("com.palantir.conjure.java.types.AliasGenerator") +public final class StringAlias implements Comparable { + private final @Safe String value; + + private StringAlias(@Nonnull @Safe String value) { + this.value = Preconditions.checkNotNull(value, "value cannot be null"); + } + + @JsonValue + public @Safe String get() { + return value; + } + + @Override + @Safe + public String toString() { + return value.toString(); + } + + @Override + public boolean equals(@Nullable Object other) { + return this == other || (other instanceof StringAlias && equalTo((StringAlias) other)); + } + + private boolean equalTo(StringAlias other) { + return this.value.equals(other.value); + } + + @Override + public int hashCode() { + return this.value.hashCode(); + } + + @Override + public int compareTo(StringAlias other) { + return value.compareTo(other.get()); + } + + public static StringAlias valueOf(@Safe String value) { + return of(value); + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static StringAlias of(@Nonnull @Safe String value) { + return new StringAlias(value); + } +} diff --git a/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/StringExample.java b/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/StringExample.java deleted file mode 100644 index 9cbceca31..000000000 --- a/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/StringExample.java +++ /dev/null @@ -1,112 +0,0 @@ -package errors.com.palantir.product; - -import com.fasterxml.jackson.annotation.JsonIgnoreProperties; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.fasterxml.jackson.annotation.JsonSetter; -import com.fasterxml.jackson.databind.annotation.JsonDeserialize; -import com.google.errorprone.annotations.CheckReturnValue; -import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.SafeArg; -import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; -import java.util.ArrayList; -import java.util.List; -import javax.annotation.Nonnull; -import javax.annotation.Nullable; -import javax.annotation.processing.Generated; - -@JsonDeserialize(builder = StringExample.Builder.class) -@Generated("com.palantir.conjure.java.types.BeanGenerator") -public final class StringExample { - private final String string; - - private StringExample(String string) { - validateFields(string); - this.string = string; - } - - @JsonProperty("string") - public String getString() { - return this.string; - } - - @Override - public boolean equals(@Nullable Object other) { - return this == other || (other instanceof StringExample && equalTo((StringExample) other)); - } - - private boolean equalTo(StringExample other) { - return this.string.equals(other.string); - } - - @Override - public int hashCode() { - return this.string.hashCode(); - } - - @Override - public String toString() { - return "StringExample{string: " + string + '}'; - } - - public static StringExample of(String string) { - return builder().string(string).build(); - } - - private static void validateFields(String string) { - List missingFields = null; - missingFields = addFieldIfMissing(missingFields, string, "string"); - if (missingFields != null) { - throw new SafeIllegalArgumentException( - "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); - } - } - - private static List addFieldIfMissing(List prev, Object fieldValue, String fieldName) { - List missingFields = prev; - if (fieldValue == null) { - if (missingFields == null) { - missingFields = new ArrayList<>(1); - } - missingFields.add(fieldName); - } - return missingFields; - } - - public static Builder builder() { - return new Builder(); - } - - @Generated("com.palantir.conjure.java.types.BeanBuilderGenerator") - @JsonIgnoreProperties(ignoreUnknown = true) - public static final class Builder { - boolean _buildInvoked; - - private String string; - - private Builder() {} - - public Builder from(StringExample other) { - checkNotBuilt(); - string(other.getString()); - return this; - } - - @JsonSetter("string") - public Builder string(@Nonnull String string) { - checkNotBuilt(); - this.string = Preconditions.checkNotNull(string, "string cannot be null"); - return this; - } - - @CheckReturnValue - public StringExample build() { - checkNotBuilt(); - this._buildInvoked = true; - return new StringExample(string); - } - - private void checkNotBuilt() { - Preconditions.checkState(!_buildInvoked, "Build has already been called"); - } - } -} diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/another/EndpointSpecificErrors.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/another/EndpointSpecificErrors.java index 5ed9d792f..36e908a18 100644 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/another/EndpointSpecificErrors.java +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/another/EndpointSpecificErrors.java @@ -1,8 +1,13 @@ package undertow.com.palantir.another; +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.palantir.conjure.java.api.errors.AbstractSerializableError; import com.palantir.conjure.java.api.errors.ErrorType; import com.palantir.conjure.java.api.errors.RemoteException; +import com.palantir.conjure.java.api.errors.SerializableError; import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.Safe; import javax.annotation.processing.Generated; @Generated("com.palantir.conjure.java.types.ErrorGenerator") @@ -18,4 +23,42 @@ public static boolean isDifferentPackage(RemoteException remoteException) { Preconditions.checkNotNull(remoteException, "remote exception must not be null"); return DIFFERENT_PACKAGE.name().equals(remoteException.getError().errorName()); } + + public static record DifferentPackageParameters() {} + + public static final class DifferentPackageSerializableError + extends AbstractSerializableError { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + DifferentPackageSerializableError( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorName") @Safe String errorName, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") DifferentPackageParameters parameters) { + super(errorCode, errorName, errorInstanceId, parameters); + } + + public SerializableError toSerializableError() { + SerializableError.Builder builder = SerializableError.builder() + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()); + return builder.build(); + } + } + + public static final class DifferentPackageException extends RemoteException { + private DifferentPackageSerializableError error; + + private int status; + + public DifferentPackageException(DifferentPackageSerializableError error, int status) { + super(error.toSerializableError(), status); + this.error = error; + this.status = status; + } + + public DifferentPackageSerializableError error() { + return error; + } + } } diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ConjureErrors.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ConjureErrors.java index b33bf14d2..443cebc86 100644 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ConjureErrors.java +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ConjureErrors.java @@ -1,8 +1,14 @@ package undertow.com.palantir.product; +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.palantir.conjure.java.api.errors.AbstractSerializableError; import com.palantir.conjure.java.api.errors.ErrorType; import com.palantir.conjure.java.api.errors.RemoteException; +import com.palantir.conjure.java.api.errors.SerializableError; import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.Safe; +import java.util.Objects; import javax.annotation.processing.Generated; @Generated("com.palantir.conjure.java.types.ErrorGenerator") @@ -20,4 +26,45 @@ public static boolean isConflictingCauseSafeArg(RemoteException remoteException) .name() .equals(remoteException.getError().errorName()); } + + public static record ConflictingCauseSafeArgParameters( + @JsonProperty("cause") @Safe String cause_, @JsonProperty("shouldThrow") @Safe boolean shouldThrow_) {} + + public static final class ConflictingCauseSafeArgSerializableError + extends AbstractSerializableError { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + ConflictingCauseSafeArgSerializableError( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorName") @Safe String errorName, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") ConflictingCauseSafeArgParameters parameters) { + super(errorCode, errorName, errorInstanceId, parameters); + } + + public SerializableError toSerializableError() { + SerializableError.Builder builder = SerializableError.builder() + .putParameters("cause", Objects.toString(parameters().cause_())) + .putParameters("shouldThrow", Objects.toString(parameters().shouldThrow_())) + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()); + return builder.build(); + } + } + + public static final class ConflictingCauseSafeArgException extends RemoteException { + private ConflictingCauseSafeArgSerializableError error; + + private int status; + + public ConflictingCauseSafeArgException(ConflictingCauseSafeArgSerializableError error, int status) { + super(error.toSerializableError(), status); + this.error = error; + this.status = status; + } + + public ConflictingCauseSafeArgSerializableError error() { + return error; + } + } } diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EndpointSpecificErrors.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EndpointSpecificErrors.java index 60616a273..76d25a537 100644 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EndpointSpecificErrors.java +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EndpointSpecificErrors.java @@ -1,8 +1,15 @@ package undertow.com.palantir.product; +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.palantir.conjure.java.api.errors.AbstractSerializableError; import com.palantir.conjure.java.api.errors.ErrorType; import com.palantir.conjure.java.api.errors.RemoteException; +import com.palantir.conjure.java.api.errors.SerializableError; import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.Safe; +import com.palantir.logsafe.Unsafe; +import java.util.Objects; import javax.annotation.processing.Generated; @Generated("com.palantir.conjure.java.types.ErrorGenerator") @@ -18,4 +25,45 @@ public static boolean isEndpointError(RemoteException remoteException) { Preconditions.checkNotNull(remoteException, "remote exception must not be null"); return ENDPOINT_ERROR.name().equals(remoteException.getError().errorName()); } + + public static record EndpointErrorParameters( + @JsonProperty("typeName") @Safe String typeName, @JsonProperty("typeDef") @Unsafe Object typeDef) {} + + public static final class EndpointErrorSerializableError + extends AbstractSerializableError { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + EndpointErrorSerializableError( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorName") @Safe String errorName, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") EndpointErrorParameters parameters) { + super(errorCode, errorName, errorInstanceId, parameters); + } + + public SerializableError toSerializableError() { + SerializableError.Builder builder = SerializableError.builder() + .putParameters("typeName", Objects.toString(parameters().typeName())) + .putParameters("typeDef", Objects.toString(parameters().typeDef())) + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()); + return builder.build(); + } + } + + public static final class EndpointErrorException extends RemoteException { + private EndpointErrorSerializableError error; + + private int status; + + public EndpointErrorException(EndpointErrorSerializableError error, int status) { + super(error.toSerializableError(), status); + this.error = error; + this.status = status; + } + + public EndpointErrorSerializableError error() { + return error; + } + } } diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EndpointSpecificTwoErrors.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EndpointSpecificTwoErrors.java index ff930dc05..963a0547a 100644 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EndpointSpecificTwoErrors.java +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EndpointSpecificTwoErrors.java @@ -1,8 +1,13 @@ package undertow.com.palantir.product; +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.palantir.conjure.java.api.errors.AbstractSerializableError; import com.palantir.conjure.java.api.errors.ErrorType; import com.palantir.conjure.java.api.errors.RemoteException; +import com.palantir.conjure.java.api.errors.SerializableError; import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.Safe; import javax.annotation.processing.Generated; @Generated("com.palantir.conjure.java.types.ErrorGenerator") @@ -18,4 +23,42 @@ public static boolean isDifferentNamespace(RemoteException remoteException) { Preconditions.checkNotNull(remoteException, "remote exception must not be null"); return DIFFERENT_NAMESPACE.name().equals(remoteException.getError().errorName()); } + + public static record DifferentNamespaceParameters() {} + + public static final class DifferentNamespaceSerializableError + extends AbstractSerializableError { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + DifferentNamespaceSerializableError( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorName") @Safe String errorName, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") DifferentNamespaceParameters parameters) { + super(errorCode, errorName, errorInstanceId, parameters); + } + + public SerializableError toSerializableError() { + SerializableError.Builder builder = SerializableError.builder() + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()); + return builder.build(); + } + } + + public static final class DifferentNamespaceException extends RemoteException { + private DifferentNamespaceSerializableError error; + + private int status; + + public DifferentNamespaceException(DifferentNamespaceSerializableError error, int status) { + super(error.toSerializableError(), status); + this.error = error; + this.status = status; + } + + public DifferentNamespaceSerializableError error() { + return error; + } + } } diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/TestErrors.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/TestErrors.java index 9f5db9eae..391a3a9ed 100644 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/TestErrors.java +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/TestErrors.java @@ -1,8 +1,16 @@ package undertow.com.palantir.product; +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.palantir.conjure.java.api.errors.AbstractSerializableError; import com.palantir.conjure.java.api.errors.ErrorType; import com.palantir.conjure.java.api.errors.RemoteException; +import com.palantir.conjure.java.api.errors.SerializableError; import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.Safe; +import com.palantir.logsafe.Unsafe; +import java.util.Map; +import java.util.Objects; import javax.annotation.processing.Generated; @Generated("com.palantir.conjure.java.types.ErrorGenerator") @@ -34,4 +42,125 @@ public static boolean isNotFound(RemoteException remoteException) { Preconditions.checkNotNull(remoteException, "remote exception must not be null"); return NOT_FOUND.name().equals(remoteException.getError().errorName()); } + + public static record ComplicatedParametersParameters( + @JsonProperty("complicatedObjectMap") @Safe Map complicatedObjectMap) {} + + public static record InvalidArgumentParameters( + @JsonProperty("field") @Safe String field, @JsonProperty("value") @Unsafe String value) {} + + public static record NotFoundParameters(@JsonProperty("resource") @Safe String resource) {} + + public static final class ComplicatedParametersSerializableError + extends AbstractSerializableError { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + ComplicatedParametersSerializableError( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorName") @Safe String errorName, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") ComplicatedParametersParameters parameters) { + super(errorCode, errorName, errorInstanceId, parameters); + } + + public SerializableError toSerializableError() { + SerializableError.Builder builder = SerializableError.builder() + .putParameters( + "complicatedObjectMap", + Objects.toString(parameters().complicatedObjectMap())) + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()); + return builder.build(); + } + } + + public static final class InvalidArgumentSerializableError + extends AbstractSerializableError { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + InvalidArgumentSerializableError( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorName") @Safe String errorName, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") InvalidArgumentParameters parameters) { + super(errorCode, errorName, errorInstanceId, parameters); + } + + public SerializableError toSerializableError() { + SerializableError.Builder builder = SerializableError.builder() + .putParameters("field", Objects.toString(parameters().field())) + .putParameters("value", Objects.toString(parameters().value())) + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()); + return builder.build(); + } + } + + public static final class NotFoundSerializableError extends AbstractSerializableError { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + NotFoundSerializableError( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorName") @Safe String errorName, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") NotFoundParameters parameters) { + super(errorCode, errorName, errorInstanceId, parameters); + } + + public SerializableError toSerializableError() { + SerializableError.Builder builder = SerializableError.builder() + .putParameters("resource", Objects.toString(parameters().resource())) + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()); + return builder.build(); + } + } + + public static final class ComplicatedParametersException extends RemoteException { + private ComplicatedParametersSerializableError error; + + private int status; + + public ComplicatedParametersException(ComplicatedParametersSerializableError error, int status) { + super(error.toSerializableError(), status); + this.error = error; + this.status = status; + } + + public ComplicatedParametersSerializableError error() { + return error; + } + } + + public static final class InvalidArgumentException extends RemoteException { + private InvalidArgumentSerializableError error; + + private int status; + + public InvalidArgumentException(InvalidArgumentSerializableError error, int status) { + super(error.toSerializableError(), status); + this.error = error; + this.status = status; + } + + public InvalidArgumentSerializableError error() { + return error; + } + } + + public static final class NotFoundException extends RemoteException { + private NotFoundSerializableError error; + + private int status; + + public NotFoundException(NotFoundSerializableError error, int status) { + super(error.toSerializableError(), status); + this.error = error; + this.status = status; + } + + public NotFoundSerializableError error() { + return error; + } + } } diff --git a/conjure-java-core/src/main/java/com/palantir/conjure/java/types/ErrorGenerator.java b/conjure-java-core/src/main/java/com/palantir/conjure/java/types/ErrorGenerator.java index a7a873e63..50191e375 100644 --- a/conjure-java-core/src/main/java/com/palantir/conjure/java/types/ErrorGenerator.java +++ b/conjure-java-core/src/main/java/com/palantir/conjure/java/types/ErrorGenerator.java @@ -16,31 +16,43 @@ package com.palantir.conjure.java.types; +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonProperty; import com.google.common.base.CaseFormat; import com.google.common.collect.ImmutableList; import com.palantir.conjure.java.ConjureAnnotations; import com.palantir.conjure.java.Generator; import com.palantir.conjure.java.Options; +import com.palantir.conjure.java.api.errors.AbstractSerializableError; import com.palantir.conjure.java.api.errors.ErrorType; import com.palantir.conjure.java.api.errors.RemoteException; +import com.palantir.conjure.java.api.errors.SerializableError; import com.palantir.conjure.java.api.errors.ServiceException; import com.palantir.conjure.java.util.ErrorGenerationUtils; import com.palantir.conjure.java.util.ErrorGenerationUtils.DeclaredEndpointErrors; +import com.palantir.conjure.java.util.JavaNameSanitizer; import com.palantir.conjure.java.util.Packages; import com.palantir.conjure.java.util.TypeFunctions; import com.palantir.conjure.spec.ConjureDefinition; import com.palantir.conjure.spec.ErrorDefinition; import com.palantir.conjure.spec.ErrorNamespace; +import com.palantir.conjure.spec.FieldDefinition; import com.palantir.conjure.spec.TypeDefinition; +import com.palantir.javapoet.AnnotationSpec; import com.palantir.javapoet.ClassName; import com.palantir.javapoet.CodeBlock; import com.palantir.javapoet.FieldSpec; import com.palantir.javapoet.JavaFile; import com.palantir.javapoet.MethodSpec; +import com.palantir.javapoet.ParameterSpec; +import com.palantir.javapoet.ParameterizedTypeName; import com.palantir.javapoet.TypeName; import com.palantir.javapoet.TypeSpec; +import com.palantir.logsafe.Safe; +import java.util.ArrayList; import java.util.List; import java.util.Map; +import java.util.Objects; import java.util.Optional; import java.util.stream.Collectors; import java.util.stream.Stream; @@ -160,14 +172,155 @@ private JavaFile generateErrorTypesForNamespace( .addMethods(methodSpecs) .addMethods(checkMethodSpecs) .addMethods(isRemoteExceptionDefinitions) - .addAnnotation(ConjureAnnotations.getConjureGeneratedAnnotation(ErrorGenerator.class)); - + .addAnnotation(ConjureAnnotations.getConjureGeneratedAnnotation(ErrorGenerator.class)) + .addAnnotation(ConjureAnnotations.getConjureGeneratedAnnotation(ErrorGenerator.class)) + .addTypes(generateErrorParameterRecords(errorTypeDefinitions, typeMapper)) + .addTypes(generateSerializableErrors(errorTypeDefinitions)) + .addTypes(generateRemoteExceptionTypes(errorTypeDefinitions)); return JavaFile.builder(conjurePackage, typeBuilder.build()) .skipJavaLangImports(true) .indent(" ") .build(); } + private static List generateRemoteExceptionTypes(List errorDefinitions) { + return errorDefinitions.stream() + .map(ErrorGenerator::generateRemoteExceptionType) + .toList(); + } + + private static TypeSpec generateRemoteExceptionType(ErrorDefinition errorDefinition) { + String remoteExceptionClassName = errorDefinition.getErrorName().getName() + "Exception"; + ClassName serializableErrorClassName = + ClassName.get("", errorDefinition.getErrorName().getName() + "SerializableError"); + + TypeSpec.Builder classBuilder = TypeSpec.classBuilder(remoteExceptionClassName) + .addModifiers(Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL) + .superclass(RemoteException.class) + .addField(FieldSpec.builder(serializableErrorClassName, "error") + .addModifiers(Modifier.PRIVATE) + .build()) + .addField(FieldSpec.builder(int.class, "status") + .addModifiers(Modifier.PRIVATE) + .build()) + .addMethod(MethodSpec.constructorBuilder() + .addModifiers(Modifier.PUBLIC) + .addParameter(serializableErrorClassName, "error") + .addParameter(int.class, "status") + .addStatement("super(error.toSerializableError(), status)") + .addStatement("this.error = error") + .addStatement("this.status = status") + .build()) + .addMethod(MethodSpec.methodBuilder("error") + .addModifiers(Modifier.PUBLIC) + .returns(serializableErrorClassName) + .addStatement("return error") + .build()); + + return classBuilder.build(); + } + + private static List generateSerializableErrors(List errorDefinitions) { + return errorDefinitions.stream() + .map(ErrorGenerator::generateSerializableError) + .toList(); + } + + private static TypeSpec generateSerializableError(ErrorDefinition errorDefinition) { + String serializableErrorClassName = errorDefinition.getErrorName().getName() + "SerializableError"; + String parameterClassNameString = ErrorGenerationUtils.errorParametersClassName( + errorDefinition.getErrorName().getName()); + ClassName parametersClassName = ClassName.get("", parameterClassNameString); + + // Create constructor + MethodSpec constructor = MethodSpec.constructorBuilder() + .addAnnotation(AnnotationSpec.builder(JsonCreator.class) + .addMember("mode", "$T.$L", JsonCreator.Mode.class, JsonCreator.Mode.PROPERTIES) + .build()) + .addParameter(ParameterSpec.builder(ClassName.get(String.class), "errorCode") + .addAnnotation(AnnotationSpec.builder(JsonProperty.class) + .addMember("value", "$S", "errorCode") + .build()) + .addAnnotation(Safe.class) + .build()) + .addParameter(ParameterSpec.builder(ClassName.get(String.class), "errorName") + .addAnnotation(AnnotationSpec.builder(JsonProperty.class) + .addMember("value", "$S", "errorName") + .build()) + .addAnnotation(Safe.class) + .build()) + .addParameter(ParameterSpec.builder(ClassName.get(String.class), "errorInstanceId") + .addAnnotation(AnnotationSpec.builder(JsonProperty.class) + .addMember("value", "$S", "errorInstanceId") + .build()) + .addAnnotation(Safe.class) + .build()) + .addParameter(ParameterSpec.builder(parametersClassName, "parameters") + .addAnnotation(AnnotationSpec.builder(JsonProperty.class) + .addMember("value", "$S", "parameters") + .build()) + .build()) + .addCode("super(errorCode, errorName, errorInstanceId, parameters);") + .build(); + + // Create the toSerializableError method + MethodSpec.Builder toSerializableErrorBuilder = MethodSpec.methodBuilder("toSerializableError") + .addModifiers(Modifier.PUBLIC) + .returns(SerializableError.class); + CodeBlock.Builder builder = CodeBlock.builder() + .add("$T builder = $T.builder()", SerializableError.Builder.class, SerializableError.class); + // Add all parameters + List allArgs = new ArrayList<>(); + allArgs.addAll(errorDefinition.getSafeArgs()); + allArgs.addAll(errorDefinition.getUnsafeArgs()); + for (FieldDefinition field : allArgs) { + String fieldName = field.getFieldName().get(); + builder.add( + ".putParameters($S, $T.toString(parameters().$L()))", + fieldName, + Objects.class, + JavaNameSanitizer.sanitizeErrorParameterName(fieldName)); + } + builder.add(".errorCode(errorCode())") + .add(".errorName(errorName())") + .add(".errorInstanceId(errorInstanceId());"); + toSerializableErrorBuilder.addCode(builder.build()); + toSerializableErrorBuilder.addStatement("return builder.build()"); + + // Create the class + TypeSpec.Builder classBuilder = TypeSpec.classBuilder(serializableErrorClassName) + .addModifiers(Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL) + .superclass( + ParameterizedTypeName.get(ClassName.get(AbstractSerializableError.class), parametersClassName)) + .addMethod(constructor) + .addMethod(toSerializableErrorBuilder.build()); + + return classBuilder.build(); + } + + private static List generateErrorParameterRecords( + List errorTypeDefinitions, TypeMapper typeMapper) { + return errorTypeDefinitions.stream() + .map(errorDefinition -> generateErrorParameterRecord(errorDefinition, typeMapper)) + .toList(); + } + + private static TypeSpec generateErrorParameterRecord(ErrorDefinition errorDefinition, TypeMapper typeMapper) { + TypeSpec.Builder parametersRecordBuilder = TypeSpec.recordBuilder(ErrorGenerationUtils.errorParametersClassName( + errorDefinition.getErrorName().getName())) + .addModifiers(Modifier.PUBLIC, Modifier.STATIC); + MethodSpec.Builder ctorBuilder = MethodSpec.constructorBuilder(); + for (FieldDefinition fieldDef : errorDefinition.getSafeArgs()) { + ctorBuilder.addParameter( + ErrorGenerationUtils.buildParameterWithSafetyAnnotationAndJsonProperty(typeMapper, fieldDef, true)); + } + for (FieldDefinition fieldDef : errorDefinition.getUnsafeArgs()) { + ctorBuilder.addParameter(ErrorGenerationUtils.buildParameterWithSafetyAnnotationAndJsonProperty( + typeMapper, fieldDef, false)); + } + return parametersRecordBuilder.recordConstructor(ctorBuilder.build()).build(); + } + private static MethodSpec generateExceptionFactory( TypeMapper typeMapper, ErrorDefinition entry, boolean withCause) { String methodName = CaseFormat.UPPER_CAMEL.to( diff --git a/conjure-java-core/src/main/java/com/palantir/conjure/java/util/ErrorGenerationUtils.java b/conjure-java-core/src/main/java/com/palantir/conjure/java/util/ErrorGenerationUtils.java index 1c871d4b4..f8c0d1220 100644 --- a/conjure-java-core/src/main/java/com/palantir/conjure/java/util/ErrorGenerationUtils.java +++ b/conjure-java-core/src/main/java/com/palantir/conjure/java/util/ErrorGenerationUtils.java @@ -16,6 +16,7 @@ package com.palantir.conjure.java.util; +import com.fasterxml.jackson.annotation.JsonProperty; import com.google.common.base.CaseFormat; import com.google.common.collect.ImmutableList; import com.palantir.conjure.java.ConjureAnnotations; @@ -62,6 +63,20 @@ public static String errorTypesClassName(ErrorNamespace namespace) { return namespace.get() + "Errors"; } + public static String errorParametersClassName(String errorName) { + return errorName + "Parameters"; + } + + public static ParameterSpec buildParameterWithSafetyAnnotationAndJsonProperty( + TypeMapper typeMapper, FieldDefinition argDefinition, boolean isSafe) { + ParameterSpec.Builder parameterBuilder = + buildParameterWithSafetyAnnotationInternal(typeMapper, argDefinition, isSafe); + parameterBuilder.addAnnotation(AnnotationSpec.builder(JsonProperty.class) + .addMember("value", "$S", argDefinition.getFieldName().get()) + .build()); + return parameterBuilder.build(); + } + public record DeclaredEndpointErrors(Set errors) { public static DeclaredEndpointErrors from(ConjureDefinition definition) { return new DeclaredEndpointErrors(definition.getServices().stream() diff --git a/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowEteResource.java b/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowEteResource.java index e6867c1fd..012ac98cc 100644 --- a/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowEteResource.java +++ b/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowEteResource.java @@ -16,17 +16,29 @@ package com.palantir.conjure.java; +import com.palantir.conjure.java.lib.Bytes; import com.palantir.conjure.java.lib.SafeLong; import com.palantir.conjure.java.undertow.lib.BinaryResponseBody; import com.palantir.ri.ResourceIdentifier; import com.palantir.tokens.auth.AuthHeader; import com.palantir.tokens.auth.BearerToken; +import errors.com.palantir.product.AnyExample; +import errors.com.palantir.product.CollectionAlias; import errors.com.palantir.product.CollectionExample; +import errors.com.palantir.product.ComplexExample; import errors.com.palantir.product.ConjureErrors; +import errors.com.palantir.product.EmptyObject; import errors.com.palantir.product.EnumExample; -import errors.com.palantir.product.OptionalCollectionExample; +import errors.com.palantir.product.ExternalExample; +import errors.com.palantir.product.NestedAlias; +import errors.com.palantir.product.NestedCollectionExample; +import errors.com.palantir.product.ObjectReference; +import errors.com.palantir.product.OptionalAlias; import errors.com.palantir.product.OptionalExample; -import errors.com.palantir.product.StringExample; +import errors.com.palantir.product.PrimitiveExample; +import errors.com.palantir.product.SafetyExample; +import errors.com.palantir.product.StringAlias; +import errors.com.palantir.product.UnionExample; import jakarta.validation.constraints.NotNull; import jakarta.ws.rs.core.StreamingOutput; import java.nio.charset.StandardCharsets; @@ -38,6 +50,7 @@ import java.util.Map; import java.util.Optional; import java.util.Set; +import java.util.UUID; import undertow.com.palantir.product.LongAlias; import undertow.com.palantir.product.NestedStringAliasExample; import undertow.com.palantir.product.SimpleEnum; @@ -188,13 +201,101 @@ public String jsonErrorsHeader(AuthHeader authHeader, String headerParameter) { public String errorParameterSerialization(AuthHeader authHeader, String headerParameter) { if (headerParameter.equals("JSON") || headerParameter.equals("TOSTRING")) { throw ConjureErrors.errorWithComplexArgs( - StringExample.of("string-example"), - 123L, - CollectionExample.of( - List.of("foo", "bar"), Map.of("foo", StringExample.of("bar")), Set.of("foo", "bar")), - OptionalExample.empty(), - OptionalCollectionExample.of(Optional.of(Map.of("foo", StringExample.of("bar")))), - EnumExample.A); + PrimitiveExample.builder() + .stringVal("example-string") + .intVal(42) + .longVal(SafeLong.of(42)) + .doubleVal(3.14) + .boolVal(true) + .ridVal(ResourceIdentifier.of("ri.service.instance.folder.object")) + .uuidVal(UUID.fromString("aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee")) + .datetimeVal(OffsetDateTime.MIN) + .binaryVal(Bytes.from("hello".getBytes(StandardCharsets.UTF_8))) + .build(), + CollectionExample.builder() + .stringList(List.of("foo", "bar", "baz")) + .stringSet(Set.of("alpha", "beta")) + .stringMap(Map.of("key1", "value1", "key2", "value2")) + .build(), + NestedCollectionExample.builder() + .nestedList(List.of(List.of("nested1", "nested2"), List.of("nested3", "nested4"))) + .nestedMap(Map.of( + "outer1", Map.of("inner1", "value1", "inner2", "value2"), + "outer2", Map.of("inner3", "value3"))) + .mixedCollection(Map.of( + "objects", + List.of( + ObjectReference.builder() + .name("obj1") + .value(100) + .build(), + ObjectReference.builder() + .name("obj2") + .value(200) + .build()))) + .build(), + OptionalExample.builder() + .optionalString(Optional.of("optional-value")) + .optionalObject(Optional.of(ObjectReference.builder() + .name("optional-obj") + .value(42) + .build())) + .optionalCollection(Optional.of(List.of("opt1", "opt2"))) + .build(), + ObjectReference.builder() + .name("reference-object") + .value(999) + .build(), + UnionExample.stringVariant("union-string-value"), + EnumExample.A, + StringAlias.of("aliased-string"), + OptionalAlias.of(Optional.of("optional-aliased-string")), + CollectionAlias.of(List.of("alias1", "alias2", "alias3")), + NestedAlias.of(StringAlias.of("nested-alias-value")), + ExternalExample.builder() + .externalLong(456L) + .optionalExternal(Optional.of(789L)) + .build(), + AnyExample.builder() + .anyValue("any-type-value") + .anyMap(Map.of( + "anyKey", + "anyValue", + "anotherKey", + 123, + "complexObjectKey", + ObjectReference.builder() + .name("complex1") + .value(1) + .build())) + .build(), + EmptyObject.of(), + ComplexExample.builder() + .metadata(Map.of( + StringAlias.of("meta1"), + Optional.of(List.of( + ObjectReference.builder() + .name("complex1") + .value(1) + .build(), + ObjectReference.builder() + .name("complex2") + .value(2) + .build())), + StringAlias.of("meta2"), Optional.empty())) + .status(EnumExample.B) + .variants(List.of( + UnionExample.intVariant(42), + UnionExample.objectVariant(ObjectReference.builder() + .name("variant-obj") + .value(99) + .build()))) + .external(Optional.of(999L)) + .build(), + SafetyExample.builder() + .safeString("safe-string-value") + .unsafeDouble(2.718) + .build()); } return "hello!"; } diff --git a/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowServiceEteTest.java b/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowServiceEteTest.java index 00be2ee36..bfb104374 100644 --- a/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowServiceEteTest.java +++ b/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowServiceEteTest.java @@ -568,26 +568,12 @@ public void testErrorParametersSerializedAsJson() { @Test public void test_json_parameter_errors() { // Get the parameters when we use TOSTRING serialization - Map toStringParams; - Map jsonParams; + Map toStringParams = Map.of(); + Map jsonParams = Map.of(); try { client.errorParameterSerialization(AuthHeader.valueOf("authHeader"), "TOSTRING"); } catch (RemoteException e) { toStringParams = e.getError().parameters(); - assertThat(toStringParams) - .containsExactlyInAnyOrderEntriesOf(Map.of( - "stringExample", - "StringExample{string: string-example}", - "primitive", - "123", - "collectionExample", - "CollectionExample{strings: [foo, bar], map: {foo=StringExample{string: bar}}, set: [foo, bar]}", - "optionalExample", - "Optional.empty", - "optionalCollectionExample", - "Optional[{foo=StringExample{string: bar}}]", - "enumExample", - "A")); } // Get the parameters when we use JSON serialization @@ -595,21 +581,10 @@ public void test_json_parameter_errors() { client.errorParameterSerialization(AuthHeader.valueOf("authHeader"), "JSON"); } catch (RemoteException e) { jsonParams = e.getError().parameters(); - assertThat(jsonParams) - .containsExactlyInAnyOrderEntriesOf(Map.of( - "stringExample", - "StringExample{string: string-example}", - "primitive", - "123", - "collectionExample", - "CollectionExample{strings: [foo, bar], map: {foo=StringExample{string: bar}}, set: [foo, bar]}", - "optionalExample", - "null", - "optionalCollectionExample", - "Optional[{foo={string=bar}}]", - "enumExample", - "A")); } + + // Assert that the two maps contain the same keys and values, logging any differences + assertThat(jsonParams).containsExactlyInAnyOrderEntriesOf(toStringParams); } private static HttpURLConnection openConnectionToTestApi(String path) throws IOException { diff --git a/conjure-java-core/src/test/java/com/palantir/conjure/java/parameterized/ParameterizedConjureGenerationTest.java b/conjure-java-core/src/test/java/com/palantir/conjure/java/parameterized/ParameterizedConjureGenerationTest.java index cc63df9fc..1d0bab314 100644 --- a/conjure-java-core/src/test/java/com/palantir/conjure/java/parameterized/ParameterizedConjureGenerationTest.java +++ b/conjure-java-core/src/test/java/com/palantir/conjure/java/parameterized/ParameterizedConjureGenerationTest.java @@ -51,26 +51,26 @@ public final class ParameterizedConjureGenerationTest { public File tempDir; private static List getTestCases() { -// return List.of(ParameterizedTestCase.builder() -// .name("errors") -// .docs("Testing error generation.") -// .files(Path.of("example-errors.yml")) -// .files(Path.of("example-errors-other.yml")) -// .files(Path.of("ete-service.yml")) -// .options(Options.builder() -// .undertowServicePrefix(true) -// .useImmutableBytes(true) -// .excludeEmptyOptionals(true) -// .jetbrainsContractAnnotations(true) -// .build()) -// .generatorTypes(List.of( -// GeneratorType.ERROR, -// GeneratorType.OBJECT, -// GeneratorType.UNDERTOW, -// GeneratorType.DIALOGUE, -// GeneratorType.ENDPOINT_ERROR)) -// .build()); - return TestCases.get(); + // return List.of(ParameterizedTestCase.builder() + // .name("errors") + // .docs("Testing error generation.") + // .files(Path.of("example-errors.yml")) + // .files(Path.of("example-errors-other.yml")) + // .files(Path.of("ete-service.yml")) + // .options(Options.builder() + // .undertowServicePrefix(true) + // .useImmutableBytes(true) + // .excludeEmptyOptionals(true) + // .jetbrainsContractAnnotations(true) + // .build()) + // .generatorTypes(List.of( + // GeneratorType.ERROR, + // GeneratorType.OBJECT, + // GeneratorType.UNDERTOW, + // GeneratorType.DIALOGUE, + // GeneratorType.ENDPOINT_ERROR)) + // .build()); + return TestCases.get(); } @ParameterizedTest diff --git a/versions.lock b/versions.lock index c1f69fbf1..5b7a9e5b2 100644 --- a/versions.lock +++ b/versions.lock @@ -44,11 +44,19 @@ com.palantir.conjure:conjure-api-objects:4.50.0 (3 constraints: 9327531f) com.palantir.conjure:conjure-generator-common:4.50.0 (2 constraints: fd13a782) +<<<<<<< HEAD com.palantir.conjure.java.api:errors:2.64.0 (8 constraints: a094bf79) com.palantir.conjure.java.api:service-config:2.64.0 (6 constraints: 3466fcd7) com.palantir.conjure.java.api:ssl-config:2.64.0 (5 constraints: b44fa72d) +======= +com.palantir.conjure.java.api:errors:2.62.0-10-g6a81a18 (8 constraints: 749a93bb) + +com.palantir.conjure.java.api:service-config:2.62.0-10-g6a81a18 (6 constraints: 1e697150) + +com.palantir.conjure.java.api:ssl-config:2.62.0-10-g6a81a18 (5 constraints: 8855770a) +>>>>>>> 86e910bd (wip code-gen) com.palantir.conjure.java.runtime:client-config:8.24.0 (6 constraints: ab6bbb28) @@ -64,15 +72,15 @@ com.palantir.dialogue:dialogue-apache-hc5-client:6.7.0 (2 constraints: 1a2974b6) com.palantir.dialogue:dialogue-blocking-channels:6.7.0 (2 constraints: 79232973) -com.palantir.dialogue:dialogue-clients:6.7.0 (1 constraints: 30088985) +com.palantir.dialogue:dialogue-clients:6.7.0 (1 constraints: b40a3dc0) com.palantir.dialogue:dialogue-core:6.7.0 (3 constraints: ea3c6541) com.palantir.dialogue:dialogue-futures:6.7.0 (3 constraints: 3e33a938) -com.palantir.dialogue:dialogue-serde:6.7.0 (3 constraints: 493156e9) +com.palantir.dialogue:dialogue-serde:6.7.0 (3 constraints: cd337445) -com.palantir.dialogue:dialogue-target:6.7.0 (7 constraints: f27a7e9a) +com.palantir.dialogue:dialogue-target:6.7.0 (7 constraints: 767da404) com.palantir.goethe:goethe:0.16.0 (1 constraints: 3905353b) @@ -172,7 +180,11 @@ org.glassfish.jersey.core:jersey-common:3.1.3 (15 constraints: 7410a287) org.hdrhistogram:HdrHistogram:2.2.2 (1 constraints: 0e100092) +<<<<<<< HEAD org.immutables:value:2.11.3 (2 constraints: 0215eac1) +======= +org.immutables:value:2.11.3 (2 constraints: 0115e9c1) +>>>>>>> 86e910bd (wip code-gen) org.jboss.logging:jboss-logging:3.5.0.Final (9 constraints: 89ae085f) @@ -238,7 +250,11 @@ com.netflix.feign:feign-jackson:8.18.0 (1 constraints: c718909e) com.palantir.conjure:conjure-core:4.50.0 (1 constraints: 3b054b3b) +<<<<<<< HEAD com.palantir.conjure.java.api:test-utils:2.64.0 (1 constraints: 3e054f3b) +======= +com.palantir.conjure.java.api:test-utils:2.62.0-10-g6a81a18 (1 constraints: 2808568c) +>>>>>>> 86e910bd (wip code-gen) com.palantir.conjure.java.runtime:conjure-java-annotations:8.24.0 (1 constraints: c418889e) diff --git a/versions.props b/versions.props index 6ff331ba6..54adb668c 100644 --- a/versions.props +++ b/versions.props @@ -12,7 +12,7 @@ com.palantir.conjure.verification:* = 0.19.0 com.palantir.conjure:* = 4.50.0 com.palantir.deadlines:* = 0.15.0 com.palantir.goethe:* = 0.16.0 -com.palantir.dialogue:* = 6.2.0-18-ge483b3c +com.palantir.dialogue:* = 6.2.0-18-gda82cd0.dirty com.palantir.human-readable-types:* = 1.7.0 com.palantir.javapoet:javapoet = 0.7.0 com.palantir.ri:resource-identifier = 2.11.0 From 2ed8db7a183bd103206ef3d68768ad6b14674f20 Mon Sep 17 00:00:00 2001 From: Pritham Marupaka Date: Tue, 5 Aug 2025 14:16:02 -0400 Subject: [PATCH 08/26] WIP: code generation --- .../product/EmptyPathServiceAsync.java | 32 +- .../product/EmptyPathServiceBlocking.java | 32 +- .../com/palantir/product/EteServiceAsync.java | 1039 +++++++++++++++- .../palantir/product/EteServiceBlocking.java | 1040 +++++++++++++++-- .../dialogue/test/api/CookieServiceAsync.java | 9 +- .../test/api/CookieServiceBlocking.java | 9 +- .../com/palantir/product/ConjureErrors.java | 28 +- .../palantir/product/ConjureServerErrors.java | 46 + .../com/palantir/product/ErrorService.java | 58 + .../palantir/product/ErrorServiceAsync.java | 482 ++++++++ .../product/ErrorServiceBlocking.java | 479 ++++++++ .../product/ErrorServiceEndpoints.java | 345 ++++++ .../com/palantir/another/ConjureErrors.java | 18 +- .../com/palantir/product/ConjureErrors.java | 2 +- .../com/palantir/product/AnyExample.java | 162 +++ .../com/palantir/product/CollectionAlias.java | 70 ++ .../palantir/product/CollectionExample.java | 219 ++++ .../com/palantir/product/ComplexExample.java | 232 ++++ .../com/palantir/product/EmptyObject.java | 28 + .../com/palantir/product/EmptyUnion.java | 186 +++ .../com/palantir/product/EnumExample.java | 205 ++++ .../com/palantir/product/ExternalExample.java | 183 +++ .../com/palantir/product/NestedAlias.java | 52 + .../product/NestedCollectionExample.java | 226 ++++ .../com/palantir/product/ObjectReference.java | 169 +++ .../com/palantir/product/OptionalAlias.java | 60 + .../com/palantir/product/OptionalExample.java | 206 ++++ .../palantir/product/PrimitiveExample.java | 345 ++++++ .../com/palantir/product/SafetyExample.java | 176 +++ .../com/palantir/product/StringAliasEx.java} | 18 +- .../com/palantir/product/UnionExample.java | 579 +++++++++ .../com/palantir/another/ConjureErrors.java | 87 ++ .../com/palantir/product/AnyExample.java | 162 +++ .../com/palantir/product/CollectionAlias.java | 70 ++ .../palantir/product/CollectionExample.java | 221 ++++ .../com/palantir/product/ComplexExample.java | 237 ++++ .../com/palantir/product/ConjureErrors.java | 571 +++++++++ .../palantir/product/ConjureJavaErrors.java | 87 ++ .../palantir/product/ConjureServerErrors.java | 21 +- .../com/palantir/product/EmptyObject.java | 28 + .../com/palantir/product/EmptyUnion.java | 186 +++ .../com/palantir/product/EnumExample.java | 205 ++++ .../product/ErrorServiceEndpoints.java | 2 +- .../com/palantir/product/ExternalExample.java | 185 +++ .../com/palantir/product/NestedAlias.java | 52 + .../product/NestedCollectionExample.java | 227 ++++ .../com/palantir/product/ObjectReference.java | 169 +++ .../com/palantir/product/OptionalAlias.java | 60 + .../com/palantir/product/OptionalExample.java | 210 ++++ .../palantir/product/PrimitiveExample.java | 345 ++++++ .../com/palantir/product/SafetyExample.java | 176 +++ .../com/palantir/product/StringAliasEx.java | 58 + .../product/UndertowErrorService.java | 4 +- .../com/palantir/product/UnionExample.java | 579 +++++++++ .../com/palantir/conjure/java/Options.java | 9 + .../DefaultStaticFactoryMethodGenerator.java | 27 +- .../dialogue/DialogueServiceGenerator.java | 9 +- .../java/util/ErrorGenerationUtils.java | 18 + .../conjure/java/UndertowEteResource.java | 10 +- .../conjure/java/parameterized/TestCases.java | 5 +- .../src/test/resources/ete-service.yml | 4 + .../resources/example-endpoint-errors.yml | 4 +- .../conjure/java/cli/ConjureJavaCli.java | 4 + 63 files changed, 10574 insertions(+), 193 deletions(-) create mode 100644 conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ConjureServerErrors.java create mode 100644 conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorService.java create mode 100644 conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorServiceAsync.java create mode 100644 conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorServiceBlocking.java create mode 100644 conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorServiceEndpoints.java create mode 100644 conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/AnyExample.java create mode 100644 conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/CollectionAlias.java create mode 100644 conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/CollectionExample.java create mode 100644 conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/ComplexExample.java create mode 100644 conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/EmptyObject.java create mode 100644 conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/EmptyUnion.java create mode 100644 conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/EnumExample.java create mode 100644 conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/ExternalExample.java create mode 100644 conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/NestedAlias.java create mode 100644 conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/NestedCollectionExample.java create mode 100644 conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/ObjectReference.java create mode 100644 conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/OptionalAlias.java create mode 100644 conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/OptionalExample.java create mode 100644 conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/PrimitiveExample.java create mode 100644 conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/SafetyExample.java rename conjure-java-core/src/integrationInput/java/{errors/com/palantir/product/StringAlias.java => jersey/com/palantir/product/StringAliasEx.java} (65%) create mode 100644 conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/UnionExample.java create mode 100644 conjure-java-core/src/integrationInput/java/undertow/com/palantir/another/ConjureErrors.java create mode 100644 conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/AnyExample.java create mode 100644 conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/CollectionAlias.java create mode 100644 conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/CollectionExample.java create mode 100644 conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ComplexExample.java create mode 100644 conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ConjureJavaErrors.java create mode 100644 conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EmptyObject.java create mode 100644 conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EmptyUnion.java create mode 100644 conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EnumExample.java create mode 100644 conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ExternalExample.java create mode 100644 conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/NestedAlias.java create mode 100644 conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/NestedCollectionExample.java create mode 100644 conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ObjectReference.java create mode 100644 conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/OptionalAlias.java create mode 100644 conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/OptionalExample.java create mode 100644 conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/PrimitiveExample.java create mode 100644 conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/SafetyExample.java create mode 100644 conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/StringAliasEx.java create mode 100644 conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/UnionExample.java diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceAsync.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceAsync.java index 1cb0a894e..6d195c014 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceAsync.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceAsync.java @@ -5,6 +5,7 @@ import com.palantir.dialogue.Channel; import com.palantir.dialogue.ConjureRuntime; import com.palantir.dialogue.Deserializer; +import com.palantir.dialogue.DeserializerArgs; import com.palantir.dialogue.DialogueService; import com.palantir.dialogue.DialogueServiceFactory; import com.palantir.dialogue.Endpoint; @@ -33,8 +34,35 @@ static EmptyPathServiceAsync of(EndpointChannelFactory _endpointChannelFactory, private final EndpointChannel emptyPathChannel = _endpointChannelFactory.endpoint(DialogueEmptyPathEndpoints.emptyPath); - private final Deserializer emptyPathDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer emptyPathDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); @Override public ListenableFuture emptyPath() { diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceBlocking.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceBlocking.java index 38a0f3426..14180963d 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceBlocking.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceBlocking.java @@ -4,6 +4,7 @@ import com.palantir.dialogue.Channel; import com.palantir.dialogue.ConjureRuntime; import com.palantir.dialogue.Deserializer; +import com.palantir.dialogue.DeserializerArgs; import com.palantir.dialogue.DialogueService; import com.palantir.dialogue.DialogueServiceFactory; import com.palantir.dialogue.Endpoint; @@ -32,8 +33,35 @@ static EmptyPathServiceBlocking of(EndpointChannelFactory _endpointChannelFactor private final EndpointChannel emptyPathChannel = _endpointChannelFactory.endpoint(DialogueEmptyPathEndpoints.emptyPath); - private final Deserializer emptyPathDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer emptyPathDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); @Override public boolean emptyPath() { diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceAsync.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceAsync.java index e4f65beff..3afa81f3a 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceAsync.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceAsync.java @@ -6,6 +6,7 @@ import com.palantir.dialogue.Channel; import com.palantir.dialogue.ConjureRuntime; import com.palantir.dialogue.Deserializer; +import com.palantir.dialogue.DeserializerArgs; import com.palantir.dialogue.DialogueService; import com.palantir.dialogue.DialogueServiceFactory; import com.palantir.dialogue.Endpoint; @@ -218,80 +219,431 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur private final EndpointChannel stringChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.string); - private final Deserializer stringDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer stringDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final EndpointChannel integerChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.integer); - private final Deserializer integerDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer integerDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final EndpointChannel double_Channel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.double_); - private final Deserializer double_Deserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer double_Deserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final EndpointChannel boolean_Channel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.boolean_); - private final Deserializer boolean_Deserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer boolean_Deserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final EndpointChannel safelongChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.safelong); - private final Deserializer safelongDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer safelongDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final EndpointChannel ridChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.rid); - private final Deserializer ridDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer ridDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final EndpointChannel bearertokenChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.bearertoken); - private final Deserializer bearertokenDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer bearertokenDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final EndpointChannel optionalStringChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalString); - private final Deserializer> optionalStringDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker>() {}); + private final Deserializer> optionalStringDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.>builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker>() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final EndpointChannel optionalEmptyChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalEmpty); - private final Deserializer> optionalEmptyDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker>() {}); + private final Deserializer> optionalEmptyDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.>builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker>() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final EndpointChannel datetimeChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.datetime); - private final Deserializer datetimeDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer datetimeDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final EndpointChannel binaryChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.binary); private final EndpointChannel pathChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.path); - private final Deserializer pathDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer pathDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final EndpointChannel externalLongPathChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.externalLongPath); - private final Deserializer externalLongPathDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer externalLongPathDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final EndpointChannel optionalExternalLongQueryChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalExternalLongQuery); - private final Deserializer> optionalExternalLongQueryDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker>() {}); + private final Deserializer> optionalExternalLongQueryDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.>builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker>() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final Serializer notNullBodySerializer = _runtime.bodySerDe().serializer(new TypeMarker() {}); @@ -299,26 +651,134 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur private final EndpointChannel notNullBodyChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.notNullBody); - private final Deserializer notNullBodyDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer notNullBodyDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final EndpointChannel aliasOneChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.aliasOne); - private final Deserializer aliasOneDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer aliasOneDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final EndpointChannel optionalAliasOneChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalAliasOne); - private final Deserializer optionalAliasOneDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer optionalAliasOneDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final EndpointChannel aliasTwoChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.aliasTwo); - private final Deserializer aliasTwoDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer aliasTwoDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final Serializer notNullBodyExternalImportSerializer = _runtime.bodySerDe() @@ -329,7 +789,50 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur private final Deserializer notNullBodyExternalImportDeserializer = _runtime.bodySerDe() - .deserializer(new TypeMarker() {}); + .deserializer( + DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success( + new TypeMarker< + allexamples.com.palantir.product.StringAliasExample>() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker< + ConjureErrors + .ConflictingCauseSafeArgSerializableError>() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker< + ConjureErrors + .ConflictingCauseUnsafeArgSerializableError>() {}, + new TypeMarker< + ConjureErrors.ConflictingCauseUnsafeArgException>() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker< + ConjureErrors.ErrorWithComplexArgsSerializableError>() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker< + ConjureErrors + .InvalidServiceDefinitionSerializableError>() {}, + new TypeMarker< + ConjureErrors.InvalidServiceDefinitionException>() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker< + ConjureErrors.InvalidTypeDefinitionSerializableError>() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker< + ConjureJavaErrors + .JavaCompilationFailedSerializableError>() {}, + new TypeMarker< + ConjureJavaErrors.JavaCompilationFailedException>() {}) + .build()); private final Serializer> optionalBodyExternalImportSerializer = _runtime.bodySerDe() @@ -342,7 +845,52 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur private final Deserializer> optionalBodyExternalImportDeserializer = _runtime.bodySerDe() .deserializer( - new TypeMarker>() {}); + DeserializerArgs + .>builder() + .baseType(new TypeMarker<>() {}) + .success( + new TypeMarker< + Optional< + allexamples.com.palantir.product + .StringAliasExample>>() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker< + ConjureErrors + .ConflictingCauseSafeArgSerializableError>() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker< + ConjureErrors + .ConflictingCauseUnsafeArgSerializableError>() {}, + new TypeMarker< + ConjureErrors.ConflictingCauseUnsafeArgException>() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker< + ConjureErrors.ErrorWithComplexArgsSerializableError>() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker< + ConjureErrors + .InvalidServiceDefinitionSerializableError>() {}, + new TypeMarker< + ConjureErrors.InvalidServiceDefinitionException>() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker< + ConjureErrors.InvalidTypeDefinitionSerializableError>() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker< + ConjureJavaErrors + .JavaCompilationFailedSerializableError>() {}, + new TypeMarker< + ConjureJavaErrors.JavaCompilationFailedException>() {}) + .build()); private final EndpointChannel optionalQueryExternalImportChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalQueryExternalImport); @@ -350,61 +898,349 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur private final Deserializer> optionalQueryExternalImportDeserializer = _runtime.bodySerDe() .deserializer( - new TypeMarker>() {}); + DeserializerArgs + .>builder() + .baseType(new TypeMarker<>() {}) + .success( + new TypeMarker< + Optional< + allexamples.com.palantir.product + .StringAliasExample>>() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker< + ConjureErrors + .ConflictingCauseSafeArgSerializableError>() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker< + ConjureErrors + .ConflictingCauseUnsafeArgSerializableError>() {}, + new TypeMarker< + ConjureErrors.ConflictingCauseUnsafeArgException>() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker< + ConjureErrors.ErrorWithComplexArgsSerializableError>() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker< + ConjureErrors + .InvalidServiceDefinitionSerializableError>() {}, + new TypeMarker< + ConjureErrors.InvalidServiceDefinitionException>() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker< + ConjureErrors.InvalidTypeDefinitionSerializableError>() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker< + ConjureJavaErrors + .JavaCompilationFailedSerializableError>() {}, + new TypeMarker< + ConjureJavaErrors.JavaCompilationFailedException>() {}) + .build()); private final EndpointChannel noReturnChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.noReturn); - private final Deserializer noReturnDeserializer = - _runtime.bodySerDe().emptyBodyDeserializer(); + private final Deserializer noReturnDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final EndpointChannel enumQueryChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.enumQuery); - private final Deserializer enumQueryDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer enumQueryDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final EndpointChannel enumListQueryChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.enumListQuery); - private final Deserializer> enumListQueryDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker>() {}); + private final Deserializer> enumListQueryDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.>builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker>() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final EndpointChannel optionalEnumQueryChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalEnumQuery); - private final Deserializer> optionalEnumQueryDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker>() {}); + private final Deserializer> optionalEnumQueryDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.>builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker>() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final EndpointChannel enumHeaderChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.enumHeader); - private final Deserializer enumHeaderDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer enumHeaderDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final EndpointChannel jsonErrorsHeaderChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.jsonErrorsHeader); - private final Deserializer jsonErrorsHeaderDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer jsonErrorsHeaderDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final EndpointChannel errorParameterSerializationChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.errorParameterSerialization); - private final Deserializer errorParameterSerializationDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer errorParameterSerializationDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final EndpointChannel aliasLongEndpointChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.aliasLongEndpoint); - private final Deserializer> aliasLongEndpointDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker>() {}); + private final Deserializer> aliasLongEndpointDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.>builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker>() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final EndpointChannel complexQueryParametersChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.complexQueryParameters); - private final Deserializer complexQueryParametersDeserializer = - _runtime.bodySerDe().emptyBodyDeserializer(); + private final Deserializer complexQueryParametersDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final Serializer>> receiveListOfOptionalsSerializer = _runtime.bodySerDe().serializer(new TypeMarker>>() {}); @@ -412,8 +1248,35 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur private final EndpointChannel receiveListOfOptionalsChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.receiveListOfOptionals); - private final Deserializer receiveListOfOptionalsDeserializer = - _runtime.bodySerDe().emptyBodyDeserializer(); + private final Deserializer receiveListOfOptionalsDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final Serializer>> receiveSetOfOptionalsSerializer = _runtime.bodySerDe().serializer(new TypeMarker>>() {}); @@ -421,8 +1284,35 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur private final EndpointChannel receiveSetOfOptionalsChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.receiveSetOfOptionals); - private final Deserializer receiveSetOfOptionalsDeserializer = - _runtime.bodySerDe().emptyBodyDeserializer(); + private final Deserializer receiveSetOfOptionalsDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final Serializer> receiveListOfStringsSerializer = _runtime.bodySerDe().serializer(new TypeMarker>() {}); @@ -430,8 +1320,35 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur private final EndpointChannel receiveListOfStringsChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.receiveListOfStrings); - private final Deserializer receiveListOfStringsDeserializer = - _runtime.bodySerDe().emptyBodyDeserializer(); + private final Deserializer receiveListOfStringsDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); @Override public ListenableFuture string(AuthHeader authHeader) { diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceBlocking.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceBlocking.java index 8bf3fc689..cc9209d0f 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceBlocking.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceBlocking.java @@ -20,8 +20,7 @@ import com.palantir.tokens.auth.AuthHeader; import com.palantir.tokens.auth.BearerToken; import errors.com.palantir.product.ConjureErrors; -import errors.com.palantir.product.ConjureErrors.ErrorWithComplexArgsException; -import errors.com.palantir.product.ConjureErrors.ErrorWithComplexArgsSerializableError; +import errors.com.palantir.product.ConjureJavaErrors; import java.io.InputStream; import java.time.OffsetDateTime; import java.util.List; @@ -214,80 +213,431 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con private final EndpointChannel stringChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.string); - private final Deserializer stringDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer stringDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final EndpointChannel integerChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.integer); - private final Deserializer integerDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer integerDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final EndpointChannel double_Channel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.double_); - private final Deserializer double_Deserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer double_Deserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final EndpointChannel boolean_Channel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.boolean_); - private final Deserializer boolean_Deserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer boolean_Deserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final EndpointChannel safelongChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.safelong); - private final Deserializer safelongDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer safelongDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final EndpointChannel ridChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.rid); - private final Deserializer ridDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer ridDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final EndpointChannel bearertokenChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.bearertoken); - private final Deserializer bearertokenDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer bearertokenDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final EndpointChannel optionalStringChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalString); - private final Deserializer> optionalStringDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker>() {}); + private final Deserializer> optionalStringDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.>builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker>() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final EndpointChannel optionalEmptyChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalEmpty); - private final Deserializer> optionalEmptyDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker>() {}); + private final Deserializer> optionalEmptyDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.>builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker>() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final EndpointChannel datetimeChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.datetime); - private final Deserializer datetimeDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer datetimeDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final EndpointChannel binaryChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.binary); private final EndpointChannel pathChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.path); - private final Deserializer pathDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer pathDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final EndpointChannel externalLongPathChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.externalLongPath); - private final Deserializer externalLongPathDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer externalLongPathDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final EndpointChannel optionalExternalLongQueryChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalExternalLongQuery); - private final Deserializer> optionalExternalLongQueryDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker>() {}); + private final Deserializer> optionalExternalLongQueryDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.>builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker>() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final Serializer notNullBodySerializer = _runtime.bodySerDe().serializer(new TypeMarker() {}); @@ -295,26 +645,134 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con private final EndpointChannel notNullBodyChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.notNullBody); - private final Deserializer notNullBodyDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer notNullBodyDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final EndpointChannel aliasOneChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.aliasOne); - private final Deserializer aliasOneDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer aliasOneDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final EndpointChannel optionalAliasOneChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalAliasOne); - private final Deserializer optionalAliasOneDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer optionalAliasOneDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final EndpointChannel aliasTwoChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.aliasTwo); - private final Deserializer aliasTwoDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer aliasTwoDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final Serializer notNullBodyExternalImportSerializer = _runtime.bodySerDe() @@ -325,7 +783,50 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con private final Deserializer notNullBodyExternalImportDeserializer = _runtime.bodySerDe() - .deserializer(new TypeMarker() {}); + .deserializer( + DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success( + new TypeMarker< + allexamples.com.palantir.product.StringAliasExample>() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker< + ConjureErrors + .ConflictingCauseSafeArgSerializableError>() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker< + ConjureErrors + .ConflictingCauseUnsafeArgSerializableError>() {}, + new TypeMarker< + ConjureErrors.ConflictingCauseUnsafeArgException>() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker< + ConjureErrors.ErrorWithComplexArgsSerializableError>() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker< + ConjureErrors + .InvalidServiceDefinitionSerializableError>() {}, + new TypeMarker< + ConjureErrors.InvalidServiceDefinitionException>() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker< + ConjureErrors.InvalidTypeDefinitionSerializableError>() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker< + ConjureJavaErrors + .JavaCompilationFailedSerializableError>() {}, + new TypeMarker< + ConjureJavaErrors.JavaCompilationFailedException>() {}) + .build()); private final Serializer> optionalBodyExternalImportSerializer = _runtime.bodySerDe() @@ -338,7 +839,52 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con private final Deserializer> optionalBodyExternalImportDeserializer = _runtime.bodySerDe() .deserializer( - new TypeMarker>() {}); + DeserializerArgs + .>builder() + .baseType(new TypeMarker<>() {}) + .success( + new TypeMarker< + Optional< + allexamples.com.palantir.product + .StringAliasExample>>() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker< + ConjureErrors + .ConflictingCauseSafeArgSerializableError>() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker< + ConjureErrors + .ConflictingCauseUnsafeArgSerializableError>() {}, + new TypeMarker< + ConjureErrors.ConflictingCauseUnsafeArgException>() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker< + ConjureErrors.ErrorWithComplexArgsSerializableError>() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker< + ConjureErrors + .InvalidServiceDefinitionSerializableError>() {}, + new TypeMarker< + ConjureErrors.InvalidServiceDefinitionException>() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker< + ConjureErrors.InvalidTypeDefinitionSerializableError>() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker< + ConjureJavaErrors + .JavaCompilationFailedSerializableError>() {}, + new TypeMarker< + ConjureJavaErrors.JavaCompilationFailedException>() {}) + .build()); private final EndpointChannel optionalQueryExternalImportChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalQueryExternalImport); @@ -346,68 +892,349 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con private final Deserializer> optionalQueryExternalImportDeserializer = _runtime.bodySerDe() .deserializer( - new TypeMarker>() {}); + DeserializerArgs + .>builder() + .baseType(new TypeMarker<>() {}) + .success( + new TypeMarker< + Optional< + allexamples.com.palantir.product + .StringAliasExample>>() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker< + ConjureErrors + .ConflictingCauseSafeArgSerializableError>() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker< + ConjureErrors + .ConflictingCauseUnsafeArgSerializableError>() {}, + new TypeMarker< + ConjureErrors.ConflictingCauseUnsafeArgException>() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker< + ConjureErrors.ErrorWithComplexArgsSerializableError>() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker< + ConjureErrors + .InvalidServiceDefinitionSerializableError>() {}, + new TypeMarker< + ConjureErrors.InvalidServiceDefinitionException>() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker< + ConjureErrors.InvalidTypeDefinitionSerializableError>() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker< + ConjureJavaErrors + .JavaCompilationFailedSerializableError>() {}, + new TypeMarker< + ConjureJavaErrors.JavaCompilationFailedException>() {}) + .build()); private final EndpointChannel noReturnChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.noReturn); - private final Deserializer noReturnDeserializer = - _runtime.bodySerDe().emptyBodyDeserializer(); + private final Deserializer noReturnDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final EndpointChannel enumQueryChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.enumQuery); - private final Deserializer enumQueryDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer enumQueryDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final EndpointChannel enumListQueryChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.enumListQuery); - private final Deserializer> enumListQueryDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker>() {}); + private final Deserializer> enumListQueryDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.>builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker>() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final EndpointChannel optionalEnumQueryChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalEnumQuery); - private final Deserializer> optionalEnumQueryDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker>() {}); + private final Deserializer> optionalEnumQueryDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.>builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker>() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final EndpointChannel enumHeaderChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.enumHeader); - private final Deserializer enumHeaderDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer enumHeaderDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final EndpointChannel jsonErrorsHeaderChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.jsonErrorsHeader); - private final Deserializer jsonErrorsHeaderDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer jsonErrorsHeaderDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final EndpointChannel errorParameterSerializationChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.errorParameterSerialization); - private final Deserializer errorParameterSerializationDeserializer = - _runtime.bodySerDe().deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker() {}) + private final Deserializer errorParameterSerializationDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) .exception( ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker(){}) + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) .build()); private final EndpointChannel aliasLongEndpointChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.aliasLongEndpoint); - private final Deserializer> aliasLongEndpointDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker>() {}); + private final Deserializer> aliasLongEndpointDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.>builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker>() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final EndpointChannel complexQueryParametersChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.complexQueryParameters); - private final Deserializer complexQueryParametersDeserializer = - _runtime.bodySerDe().emptyBodyDeserializer(); + private final Deserializer complexQueryParametersDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final Serializer>> receiveListOfOptionalsSerializer = _runtime.bodySerDe().serializer(new TypeMarker>>() {}); @@ -415,8 +1242,35 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con private final EndpointChannel receiveListOfOptionalsChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.receiveListOfOptionals); - private final Deserializer receiveListOfOptionalsDeserializer = - _runtime.bodySerDe().emptyBodyDeserializer(); + private final Deserializer receiveListOfOptionalsDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final Serializer>> receiveSetOfOptionalsSerializer = _runtime.bodySerDe().serializer(new TypeMarker>>() {}); @@ -424,8 +1278,35 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con private final EndpointChannel receiveSetOfOptionalsChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.receiveSetOfOptionals); - private final Deserializer receiveSetOfOptionalsDeserializer = - _runtime.bodySerDe().emptyBodyDeserializer(); + private final Deserializer receiveSetOfOptionalsDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); private final Serializer> receiveListOfStringsSerializer = _runtime.bodySerDe().serializer(new TypeMarker>() {}); @@ -433,8 +1314,35 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con private final EndpointChannel receiveListOfStringsChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.receiveListOfStrings); - private final Deserializer receiveListOfStringsDeserializer = - _runtime.bodySerDe().emptyBodyDeserializer(); + private final Deserializer receiveListOfStringsDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build()); @Override public String string(AuthHeader authHeader) { diff --git a/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceAsync.java b/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceAsync.java index 835e97b78..6f3b550c2 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceAsync.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceAsync.java @@ -5,6 +5,7 @@ import com.palantir.dialogue.Channel; import com.palantir.dialogue.ConjureRuntime; import com.palantir.dialogue.Deserializer; +import com.palantir.dialogue.DeserializerArgs; import com.palantir.dialogue.DialogueService; import com.palantir.dialogue.DialogueServiceFactory; import com.palantir.dialogue.Endpoint; @@ -12,6 +13,7 @@ import com.palantir.dialogue.EndpointChannelFactory; import com.palantir.dialogue.PlainSerDe; import com.palantir.dialogue.Request; +import com.palantir.dialogue.TypeMarker; import com.palantir.tokens.auth.BearerToken; import java.lang.Override; import java.lang.String; @@ -33,8 +35,11 @@ static CookieServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Con private final EndpointChannel eatCookiesChannel = _endpointChannelFactory.endpoint(DialogueCookieEndpoints.eatCookies); - private final Deserializer eatCookiesDeserializer = - _runtime.bodySerDe().emptyBodyDeserializer(); + private final Deserializer eatCookiesDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .build()); @Override public ListenableFuture eatCookies(BearerToken token) { diff --git a/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceBlocking.java b/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceBlocking.java index 78e6e8cc0..8c0fc9e04 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceBlocking.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceBlocking.java @@ -4,6 +4,7 @@ import com.palantir.dialogue.Channel; import com.palantir.dialogue.ConjureRuntime; import com.palantir.dialogue.Deserializer; +import com.palantir.dialogue.DeserializerArgs; import com.palantir.dialogue.DialogueService; import com.palantir.dialogue.DialogueServiceFactory; import com.palantir.dialogue.Endpoint; @@ -11,6 +12,7 @@ import com.palantir.dialogue.EndpointChannelFactory; import com.palantir.dialogue.PlainSerDe; import com.palantir.dialogue.Request; +import com.palantir.dialogue.TypeMarker; import com.palantir.tokens.auth.BearerToken; import java.lang.Override; import java.lang.String; @@ -32,8 +34,11 @@ static CookieServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, private final EndpointChannel eatCookiesChannel = _endpointChannelFactory.endpoint(DialogueCookieEndpoints.eatCookies); - private final Deserializer eatCookiesDeserializer = - _runtime.bodySerDe().emptyBodyDeserializer(); + private final Deserializer eatCookiesDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .build()); @Override public void eatCookies(BearerToken token) { diff --git a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ConjureErrors.java b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ConjureErrors.java index 052aefcba..d01fa290a 100644 --- a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ConjureErrors.java +++ b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ConjureErrors.java @@ -14,30 +14,30 @@ @Generated("com.palantir.conjure.java.types.ErrorGenerator") public final class ConjureErrors { /** Cause argument conflicts with reserved Throwable cause parameter. */ - public static final ErrorType CONFLICTING_CAUSE_SAFE_ARG = - ErrorType.create(ErrorType.Code.INTERNAL, "Conjure:ConflictingCauseSafeArg"); + public static final ErrorType CONFLICTING_CAUSE_SAFE_ARG_ERR = + ErrorType.create(ErrorType.Code.INTERNAL, "Conjure:ConflictingCauseSafeArgErr"); private ConjureErrors() {} - /** Returns true if the {@link RemoteException} is named Conjure:ConflictingCauseSafeArg */ - public static boolean isConflictingCauseSafeArg(RemoteException remoteException) { + /** Returns true if the {@link RemoteException} is named Conjure:ConflictingCauseSafeArgErr */ + public static boolean isConflictingCauseSafeArgErr(RemoteException remoteException) { Preconditions.checkNotNull(remoteException, "remote exception must not be null"); - return CONFLICTING_CAUSE_SAFE_ARG + return CONFLICTING_CAUSE_SAFE_ARG_ERR .name() .equals(remoteException.getError().errorName()); } - public static record ConflictingCauseSafeArgParameters( + public static record ConflictingCauseSafeArgErrParameters( @JsonProperty("cause") @Safe String cause_, @JsonProperty("shouldThrow") @Safe boolean shouldThrow_) {} - public static final class ConflictingCauseSafeArgSerializableError - extends AbstractSerializableError { + public static final class ConflictingCauseSafeArgErrSerializableError + extends AbstractSerializableError { @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - ConflictingCauseSafeArgSerializableError( + ConflictingCauseSafeArgErrSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") ConflictingCauseSafeArgParameters parameters) { + @JsonProperty("parameters") ConflictingCauseSafeArgErrParameters parameters) { super(errorCode, errorName, errorInstanceId, parameters); } @@ -52,18 +52,18 @@ public SerializableError toSerializableError() { } } - public static final class ConflictingCauseSafeArgException extends RemoteException { - private ConflictingCauseSafeArgSerializableError error; + public static final class ConflictingCauseSafeArgErrException extends RemoteException { + private ConflictingCauseSafeArgErrSerializableError error; private int status; - public ConflictingCauseSafeArgException(ConflictingCauseSafeArgSerializableError error, int status) { + public ConflictingCauseSafeArgErrException(ConflictingCauseSafeArgErrSerializableError error, int status) { super(error.toSerializableError(), status); this.error = error; this.status = status; } - public ConflictingCauseSafeArgSerializableError error() { + public ConflictingCauseSafeArgErrSerializableError error() { return error; } } diff --git a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ConjureServerErrors.java b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ConjureServerErrors.java new file mode 100644 index 000000000..23539b031 --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ConjureServerErrors.java @@ -0,0 +1,46 @@ +package dialogueendpointresulttypes.com.palantir.product; + +import com.palantir.conjure.java.api.errors.EndpointServiceException; +import com.palantir.logsafe.Safe; +import com.palantir.logsafe.SafeArg; +import javax.annotation.Nullable; +import javax.annotation.processing.Generated; + +@Generated("com.palantir.conjure.java.types.EndpointErrorGenerator") +public final class ConjureServerErrors { + private ConjureServerErrors() {} + + public static ConflictingCauseSafeArgErr conflictingCauseSafeArgErr( + @Safe String cause_, @Safe boolean shouldThrow_) { + return new ConflictingCauseSafeArgErr(cause_, shouldThrow_, null); + } + + public static ConflictingCauseSafeArgErr conflictingCauseSafeArgErr( + @Safe String cause_, @Safe boolean shouldThrow_, @Nullable Throwable cause) { + return new ConflictingCauseSafeArgErr(cause_, shouldThrow_, cause); + } + + /** + * Throws a {@link ConflictingCauseSafeArgErr} when {@code shouldThrow} is true. + * + * @param shouldThrow Cause the method to throw when true + * @param cause_ + * @param shouldThrow_ + */ + public static void throwIfConflictingCauseSafeArgErr( + boolean shouldThrow, @Safe String cause_, @Safe boolean shouldThrow_) { + if (shouldThrow) { + throw conflictingCauseSafeArgErr(cause_, shouldThrow_); + } + } + + public static final class ConflictingCauseSafeArgErr extends EndpointServiceException { + private ConflictingCauseSafeArgErr(@Safe String cause_, @Safe boolean shouldThrow_, @Nullable Throwable cause) { + super( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG_ERR, + cause, + SafeArg.of("cause", cause_), + SafeArg.of("shouldThrow", shouldThrow_)); + } + } +} diff --git a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorService.java b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorService.java new file mode 100644 index 000000000..3d350a4c9 --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorService.java @@ -0,0 +1,58 @@ +package dialogueendpointresulttypes.com.palantir.product; + +import com.palantir.conjure.java.undertow.lib.BinaryResponseBody; +import com.palantir.tokens.auth.AuthHeader; +import java.util.Optional; +import javax.annotation.processing.Generated; + +@Generated("com.palantir.conjure.java.services.UndertowServiceInterfaceGenerator") +public interface ErrorService { + /** + * @apiNote {@code POST /errors/basic} + * @throws TestServerErrors.InvalidArgument + * @throws ConjureServerErrors.ConflictingCauseSafeArgErr + */ + String testBasicError(AuthHeader authHeader, boolean shouldThrowError) + throws TestServerErrors.InvalidArgument, ConjureServerErrors.ConflictingCauseSafeArgErr; + + /** + * @apiNote {@code POST /errors/imported} + * @throws EndpointSpecificServerErrors.EndpointError + */ + String testImportedError(AuthHeader authHeader, boolean shouldThrowError) + throws EndpointSpecificServerErrors.EndpointError; + + /** + * @apiNote {@code POST /errors/multiple} + * @throws TestServerErrors.InvalidArgument + * @throws TestServerErrors.NotFound Something was not found. + * @throws EndpointSpecificTwoServerErrors.DifferentNamespace + * @throws dialogueendpointresulttypes.com.palantir.another.EndpointSpecificServerErrors.DifferentPackage + * @throws TestServerErrors.ComplicatedParameters + */ + String testMultipleErrorsAndPackages(AuthHeader authHeader, Optional errorToThrow) + throws TestServerErrors.InvalidArgument, TestServerErrors.NotFound, + EndpointSpecificTwoServerErrors.DifferentNamespace, + dialogueendpointresulttypes.com.palantir.another.EndpointSpecificServerErrors.DifferentPackage, + TestServerErrors.ComplicatedParameters; + + /** + * @apiNote {@code POST /errors/empty} + * @throws TestServerErrors.InvalidArgument + */ + void testEmptyBody(AuthHeader authHeader, boolean shouldThrowError) throws TestServerErrors.InvalidArgument; + + /** + * @apiNote {@code POST /errors/binary} + * @throws TestServerErrors.InvalidArgument + */ + BinaryResponseBody testBinary(AuthHeader authHeader, boolean shouldThrowError) + throws TestServerErrors.InvalidArgument; + + /** + * @apiNote {@code POST /errors/optional-binary} + * @throws TestServerErrors.InvalidArgument + */ + Optional testOptionalBinary(AuthHeader authHeader, OptionalBinaryResponseMode mode) + throws TestServerErrors.InvalidArgument; +} diff --git a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorServiceAsync.java b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorServiceAsync.java new file mode 100644 index 000000000..06c57b75c --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorServiceAsync.java @@ -0,0 +1,482 @@ +package dialogueendpointresulttypes.com.palantir.product; + +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonValue; +import com.google.common.util.concurrent.ListenableFuture; +import com.google.errorprone.annotations.CheckReturnValue; +import com.google.errorprone.annotations.MustBeClosed; +import com.palantir.conjure.java.lib.internal.ClientEndpoint; +import com.palantir.dialogue.Channel; +import com.palantir.dialogue.ConjureRuntime; +import com.palantir.dialogue.Deserializer; +import com.palantir.dialogue.DeserializerArgs; +import com.palantir.dialogue.DialogueService; +import com.palantir.dialogue.DialogueServiceFactory; +import com.palantir.dialogue.Endpoint; +import com.palantir.dialogue.EndpointChannel; +import com.palantir.dialogue.EndpointChannelFactory; +import com.palantir.dialogue.EndpointError; +import com.palantir.dialogue.PlainSerDe; +import com.palantir.dialogue.Request; +import com.palantir.dialogue.Serializer; +import com.palantir.dialogue.TypeMarker; +import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.Safe; +import com.palantir.tokens.auth.AuthHeader; +import java.io.Closeable; +import java.io.IOException; +import java.io.InputStream; +import java.lang.Boolean; +import java.lang.Override; +import java.lang.String; +import java.util.Optional; +import javax.annotation.processing.Generated; + +@Generated("com.palantir.conjure.java.services.dialogue.DialogueInterfaceGenerator") +@DialogueService(ErrorServiceAsync.Factory.class) +public interface ErrorServiceAsync { + /** @apiNote {@code POST /errors/basic} */ + @ClientEndpoint(method = "POST", path = "/errors/basic") + @CheckReturnValue + ListenableFuture testBasicError(AuthHeader authHeader, boolean shouldThrowError); + + /** @apiNote {@code POST /errors/imported} */ + @ClientEndpoint(method = "POST", path = "/errors/imported") + @CheckReturnValue + ListenableFuture testImportedError(AuthHeader authHeader, boolean shouldThrowError); + + /** @apiNote {@code POST /errors/multiple} */ + @ClientEndpoint(method = "POST", path = "/errors/multiple") + @CheckReturnValue + ListenableFuture testMultipleErrorsAndPackages( + AuthHeader authHeader, Optional errorToThrow); + + /** @apiNote {@code POST /errors/empty} */ + @ClientEndpoint(method = "POST", path = "/errors/empty") + @CheckReturnValue + ListenableFuture testEmptyBody(AuthHeader authHeader, boolean shouldThrowError); + + /** @apiNote {@code POST /errors/binary} */ + @ClientEndpoint(method = "POST", path = "/errors/binary") + @CheckReturnValue + ListenableFuture testBinary(AuthHeader authHeader, boolean shouldThrowError); + + /** @apiNote {@code POST /errors/optional-binary} */ + @ClientEndpoint(method = "POST", path = "/errors/optional-binary") + @CheckReturnValue + ListenableFuture testOptionalBinary( + AuthHeader authHeader, OptionalBinaryResponseMode mode); + + /** Creates an asynchronous/non-blocking client for a ErrorService service. */ + static ErrorServiceAsync of(EndpointChannelFactory _endpointChannelFactory, ConjureRuntime _runtime) { + return new ErrorServiceAsync() { + private final PlainSerDe _plainSerDe = _runtime.plainSerDe(); + + private final Serializer testBasicErrorSerializer = + _runtime.bodySerDe().serializer(new TypeMarker() {}); + + private final EndpointChannel testBasicErrorChannel = + _endpointChannelFactory.endpoint(DialogueErrorEndpoints.testBasicError); + + private final Deserializer testBasicErrorDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .error( + TestErrors.INVALID_ARGUMENT.name(), + new TypeMarker() {}) + .error( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG_ERR.name(), + new TypeMarker() {}) + .build()); + + private final Serializer testImportedErrorSerializer = + _runtime.bodySerDe().serializer(new TypeMarker() {}); + + private final EndpointChannel testImportedErrorChannel = + _endpointChannelFactory.endpoint(DialogueErrorEndpoints.testImportedError); + + private final Deserializer testImportedErrorDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .error( + EndpointSpecificErrors.ENDPOINT_ERROR.name(), + new TypeMarker() {}) + .build()); + + private final Serializer> testMultipleErrorsAndPackagesSerializer = + _runtime.bodySerDe().serializer(new TypeMarker>() {}); + + private final EndpointChannel testMultipleErrorsAndPackagesChannel = + _endpointChannelFactory.endpoint(DialogueErrorEndpoints.testMultipleErrorsAndPackages); + + private final Deserializer + testMultipleErrorsAndPackagesDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .error( + TestErrors.INVALID_ARGUMENT.name(), + new TypeMarker() {}) + .error( + TestErrors.NOT_FOUND.name(), + new TypeMarker() {}) + .error( + EndpointSpecificTwoErrors.DIFFERENT_NAMESPACE.name(), + new TypeMarker< + TestMultipleErrorsAndPackagesResponse.DifferentNamespace>() {}) + .error( + dialogueendpointresulttypes.com.palantir.another.EndpointSpecificErrors + .DIFFERENT_PACKAGE + .name(), + new TypeMarker() {}) + .error( + TestErrors.COMPLICATED_PARAMETERS.name(), + new TypeMarker< + TestMultipleErrorsAndPackagesResponse.ComplicatedParameters>() {}) + .build()); + + private final Serializer testEmptyBodySerializer = + _runtime.bodySerDe().serializer(new TypeMarker() {}); + + private final EndpointChannel testEmptyBodyChannel = + _endpointChannelFactory.endpoint(DialogueErrorEndpoints.testEmptyBody); + + private final Deserializer testEmptyBodyDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .error( + TestErrors.INVALID_ARGUMENT.name(), + new TypeMarker() {}) + .build()); + + private final Serializer testBinarySerializer = + _runtime.bodySerDe().serializer(new TypeMarker() {}); + + private final EndpointChannel testBinaryChannel = + _endpointChannelFactory.endpoint(DialogueErrorEndpoints.testBinary); + + private final Deserializer testBinaryDeserializer = _runtime.bodySerDe() + .inputStreamDeserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .error( + TestErrors.INVALID_ARGUMENT.name(), + new TypeMarker() {}) + .build()); + + private final Serializer testOptionalBinarySerializer = + _runtime.bodySerDe().serializer(new TypeMarker() {}); + + private final EndpointChannel testOptionalBinaryChannel = + _endpointChannelFactory.endpoint(DialogueErrorEndpoints.testOptionalBinary); + + private final Deserializer testOptionalBinaryDeserializer = _runtime.bodySerDe() + .optionalInputStreamDeserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .error( + TestErrors.INVALID_ARGUMENT.name(), + new TypeMarker() {}) + .build()); + + @Override + public ListenableFuture testBasicError( + AuthHeader authHeader, boolean shouldThrowError) { + Request.Builder _request = Request.builder(); + _request.putHeaderParams("Authorization", authHeader.toString()); + _request.body(testBasicErrorSerializer.serialize(shouldThrowError)); + return _runtime.clients().call(testBasicErrorChannel, _request.build(), testBasicErrorDeserializer); + } + + @Override + public ListenableFuture testImportedError( + AuthHeader authHeader, boolean shouldThrowError) { + Request.Builder _request = Request.builder(); + _request.putHeaderParams("Authorization", authHeader.toString()); + _request.body(testImportedErrorSerializer.serialize(shouldThrowError)); + return _runtime.clients() + .call(testImportedErrorChannel, _request.build(), testImportedErrorDeserializer); + } + + @Override + public ListenableFuture testMultipleErrorsAndPackages( + AuthHeader authHeader, Optional errorToThrow) { + Request.Builder _request = Request.builder(); + _request.putHeaderParams("Authorization", authHeader.toString()); + _request.body(testMultipleErrorsAndPackagesSerializer.serialize(errorToThrow)); + return _runtime.clients() + .call( + testMultipleErrorsAndPackagesChannel, + _request.build(), + testMultipleErrorsAndPackagesDeserializer); + } + + @Override + public ListenableFuture testEmptyBody( + AuthHeader authHeader, boolean shouldThrowError) { + Request.Builder _request = Request.builder(); + _request.putHeaderParams("Authorization", authHeader.toString()); + _request.body(testEmptyBodySerializer.serialize(shouldThrowError)); + return _runtime.clients().call(testEmptyBodyChannel, _request.build(), testEmptyBodyDeserializer); + } + + @Override + public ListenableFuture testBinary(AuthHeader authHeader, boolean shouldThrowError) { + Request.Builder _request = Request.builder(); + _request.putHeaderParams("Authorization", authHeader.toString()); + _request.body(testBinarySerializer.serialize(shouldThrowError)); + return _runtime.clients().call(testBinaryChannel, _request.build(), testBinaryDeserializer); + } + + @Override + public ListenableFuture testOptionalBinary( + AuthHeader authHeader, OptionalBinaryResponseMode mode) { + Request.Builder _request = Request.builder(); + _request.putHeaderParams("Authorization", authHeader.toString()); + _request.body(testOptionalBinarySerializer.serialize(mode)); + return _runtime.clients() + .call(testOptionalBinaryChannel, _request.build(), testOptionalBinaryDeserializer); + } + + @Override + public String toString() { + return "ErrorServiceAsync{_endpointChannelFactory=" + _endpointChannelFactory + ", runtime=" + _runtime + + '}'; + } + }; + } + + /** Creates an asynchronous/non-blocking client for a ErrorService service. */ + static ErrorServiceAsync of(Channel _channel, ConjureRuntime _runtime) { + if (_channel instanceof EndpointChannelFactory) { + return of((EndpointChannelFactory) _channel, _runtime); + } + return of( + new EndpointChannelFactory() { + @Override + public EndpointChannel endpoint(Endpoint endpoint) { + return _runtime.clients().bind(_channel, endpoint); + } + }, + _runtime); + } + + final class Factory implements DialogueServiceFactory { + @Override + public ErrorServiceAsync create(EndpointChannelFactory endpointChannelFactory, ConjureRuntime runtime) { + return ErrorServiceAsync.of(endpointChannelFactory, runtime); + } + } + + sealed interface TestBasicErrorResponse + permits TestBasicErrorResponse.Success, + TestBasicErrorResponse.InvalidArgument, + TestBasicErrorResponse.ConflictingCauseSafeArgErr { + record Success(@JsonValue String value) implements TestBasicErrorResponse { + public Success { + Preconditions.checkArgumentNotNull(value, "value cannot be null"); + } + } + + final class InvalidArgument extends EndpointError + implements TestBasicErrorResponse { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + InvalidArgument( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") TestErrors.InvalidArgumentParameters parameters) { + super(errorCode, TestErrors.INVALID_ARGUMENT.name(), errorInstanceId, parameters); + } + } + + final class ConflictingCauseSafeArgErr extends EndpointError + implements TestBasicErrorResponse { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + ConflictingCauseSafeArgErr( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") ConjureErrors.ConflictingCauseSafeArgErrParameters parameters) { + super(errorCode, ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG_ERR.name(), errorInstanceId, parameters); + } + } + } + + sealed interface TestImportedErrorResponse + permits TestImportedErrorResponse.Success, TestImportedErrorResponse.EndpointError { + record Success(@JsonValue String value) implements TestImportedErrorResponse { + public Success { + Preconditions.checkArgumentNotNull(value, "value cannot be null"); + } + } + + final class EndpointError + extends com.palantir.dialogue.EndpointError + implements TestImportedErrorResponse { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + EndpointError( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") EndpointSpecificErrors.EndpointErrorParameters parameters) { + super(errorCode, EndpointSpecificErrors.ENDPOINT_ERROR.name(), errorInstanceId, parameters); + } + } + } + + sealed interface TestMultipleErrorsAndPackagesResponse + permits TestMultipleErrorsAndPackagesResponse.Success, + TestMultipleErrorsAndPackagesResponse.InvalidArgument, + TestMultipleErrorsAndPackagesResponse.NotFound, + TestMultipleErrorsAndPackagesResponse.DifferentNamespace, + TestMultipleErrorsAndPackagesResponse.DifferentPackage, + TestMultipleErrorsAndPackagesResponse.ComplicatedParameters { + record Success(@JsonValue String value) implements TestMultipleErrorsAndPackagesResponse { + public Success { + Preconditions.checkArgumentNotNull(value, "value cannot be null"); + } + } + + final class InvalidArgument extends EndpointError + implements TestMultipleErrorsAndPackagesResponse { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + InvalidArgument( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") TestErrors.InvalidArgumentParameters parameters) { + super(errorCode, TestErrors.INVALID_ARGUMENT.name(), errorInstanceId, parameters); + } + } + + final class NotFound extends EndpointError + implements TestMultipleErrorsAndPackagesResponse { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + NotFound( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") TestErrors.NotFoundParameters parameters) { + super(errorCode, TestErrors.NOT_FOUND.name(), errorInstanceId, parameters); + } + } + + final class DifferentNamespace extends EndpointError + implements TestMultipleErrorsAndPackagesResponse { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + DifferentNamespace( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId) { + super( + errorCode, + EndpointSpecificTwoErrors.DIFFERENT_NAMESPACE.name(), + errorInstanceId, + new EndpointSpecificTwoErrors.DifferentNamespaceParameters()); + } + } + + final class DifferentPackage + extends EndpointError< + dialogueendpointresulttypes.com.palantir.another.EndpointSpecificErrors + .DifferentPackageParameters> + implements TestMultipleErrorsAndPackagesResponse { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + DifferentPackage( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId) { + super( + errorCode, + dialogueendpointresulttypes.com.palantir.another.EndpointSpecificErrors.DIFFERENT_PACKAGE + .name(), + errorInstanceId, + new dialogueendpointresulttypes.com.palantir.another.EndpointSpecificErrors + .DifferentPackageParameters()); + } + } + + final class ComplicatedParameters extends EndpointError + implements TestMultipleErrorsAndPackagesResponse { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + ComplicatedParameters( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") TestErrors.ComplicatedParametersParameters parameters) { + super(errorCode, TestErrors.COMPLICATED_PARAMETERS.name(), errorInstanceId, parameters); + } + } + } + + sealed interface TestEmptyBodyResponse + permits TestEmptyBodyResponse.Success, TestEmptyBodyResponse.InvalidArgument { + record Success() implements TestEmptyBodyResponse {} + + final class InvalidArgument extends EndpointError + implements TestEmptyBodyResponse { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + InvalidArgument( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") TestErrors.InvalidArgumentParameters parameters) { + super(errorCode, TestErrors.INVALID_ARGUMENT.name(), errorInstanceId, parameters); + } + } + } + + sealed interface TestBinaryResponse extends Closeable + permits TestBinaryResponse.Success, TestBinaryResponse.InvalidArgument { + @Override + default void close() throws IOException {} + + record Success(@MustBeClosed @JsonValue InputStream value) implements TestBinaryResponse { + public Success { + Preconditions.checkArgumentNotNull(value, "value cannot be null"); + } + + @Override + public void close() throws IOException { + value.close(); + } + } + + final class InvalidArgument extends EndpointError + implements TestBinaryResponse { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + InvalidArgument( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") TestErrors.InvalidArgumentParameters parameters) { + super(errorCode, TestErrors.INVALID_ARGUMENT.name(), errorInstanceId, parameters); + } + } + } + + sealed interface TestOptionalBinaryResponse extends Closeable + permits TestOptionalBinaryResponse.Success, TestOptionalBinaryResponse.InvalidArgument { + @Override + default void close() throws IOException {} + + record Success(@JsonValue Optional value) implements TestOptionalBinaryResponse { + public Success { + Preconditions.checkArgumentNotNull(value, "value cannot be null"); + } + + @Override + public void close() throws IOException { + if (value.isPresent()) { + value.get().close(); + } + } + } + + final class InvalidArgument extends EndpointError + implements TestOptionalBinaryResponse { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + InvalidArgument( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") TestErrors.InvalidArgumentParameters parameters) { + super(errorCode, TestErrors.INVALID_ARGUMENT.name(), errorInstanceId, parameters); + } + } + } +} diff --git a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorServiceBlocking.java b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorServiceBlocking.java new file mode 100644 index 000000000..056d33312 --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorServiceBlocking.java @@ -0,0 +1,479 @@ +package dialogueendpointresulttypes.com.palantir.product; + +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonValue; +import com.google.errorprone.annotations.CheckReturnValue; +import com.google.errorprone.annotations.MustBeClosed; +import com.palantir.conjure.java.lib.internal.ClientEndpoint; +import com.palantir.dialogue.Channel; +import com.palantir.dialogue.ConjureRuntime; +import com.palantir.dialogue.Deserializer; +import com.palantir.dialogue.DeserializerArgs; +import com.palantir.dialogue.DialogueService; +import com.palantir.dialogue.DialogueServiceFactory; +import com.palantir.dialogue.Endpoint; +import com.palantir.dialogue.EndpointChannel; +import com.palantir.dialogue.EndpointChannelFactory; +import com.palantir.dialogue.EndpointError; +import com.palantir.dialogue.PlainSerDe; +import com.palantir.dialogue.Request; +import com.palantir.dialogue.Serializer; +import com.palantir.dialogue.TypeMarker; +import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.Safe; +import com.palantir.tokens.auth.AuthHeader; +import java.io.Closeable; +import java.io.IOException; +import java.io.InputStream; +import java.lang.Boolean; +import java.lang.Override; +import java.lang.String; +import java.util.Optional; +import javax.annotation.processing.Generated; + +@Generated("com.palantir.conjure.java.services.dialogue.DialogueInterfaceGenerator") +@DialogueService(ErrorServiceBlocking.Factory.class) +public interface ErrorServiceBlocking { + /** @apiNote {@code POST /errors/basic} */ + @ClientEndpoint(method = "POST", path = "/errors/basic") + @CheckReturnValue + TestBasicErrorResponse testBasicError(AuthHeader authHeader, boolean shouldThrowError); + + /** @apiNote {@code POST /errors/imported} */ + @ClientEndpoint(method = "POST", path = "/errors/imported") + @CheckReturnValue + TestImportedErrorResponse testImportedError(AuthHeader authHeader, boolean shouldThrowError); + + /** @apiNote {@code POST /errors/multiple} */ + @ClientEndpoint(method = "POST", path = "/errors/multiple") + @CheckReturnValue + TestMultipleErrorsAndPackagesResponse testMultipleErrorsAndPackages( + AuthHeader authHeader, Optional errorToThrow); + + /** @apiNote {@code POST /errors/empty} */ + @ClientEndpoint(method = "POST", path = "/errors/empty") + @CheckReturnValue + TestEmptyBodyResponse testEmptyBody(AuthHeader authHeader, boolean shouldThrowError); + + /** @apiNote {@code POST /errors/binary} */ + @ClientEndpoint(method = "POST", path = "/errors/binary") + @CheckReturnValue + TestBinaryResponse testBinary(AuthHeader authHeader, boolean shouldThrowError); + + /** @apiNote {@code POST /errors/optional-binary} */ + @ClientEndpoint(method = "POST", path = "/errors/optional-binary") + @CheckReturnValue + TestOptionalBinaryResponse testOptionalBinary(AuthHeader authHeader, OptionalBinaryResponseMode mode); + + /** Creates a synchronous/blocking client for a ErrorService service. */ + static ErrorServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, ConjureRuntime _runtime) { + return new ErrorServiceBlocking() { + private final PlainSerDe _plainSerDe = _runtime.plainSerDe(); + + private final Serializer testBasicErrorSerializer = + _runtime.bodySerDe().serializer(new TypeMarker() {}); + + private final EndpointChannel testBasicErrorChannel = + _endpointChannelFactory.endpoint(DialogueErrorEndpoints.testBasicError); + + private final Deserializer testBasicErrorDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .error( + TestErrors.INVALID_ARGUMENT.name(), + new TypeMarker() {}) + .error( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG_ERR.name(), + new TypeMarker() {}) + .build()); + + private final Serializer testImportedErrorSerializer = + _runtime.bodySerDe().serializer(new TypeMarker() {}); + + private final EndpointChannel testImportedErrorChannel = + _endpointChannelFactory.endpoint(DialogueErrorEndpoints.testImportedError); + + private final Deserializer testImportedErrorDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .error( + EndpointSpecificErrors.ENDPOINT_ERROR.name(), + new TypeMarker() {}) + .build()); + + private final Serializer> testMultipleErrorsAndPackagesSerializer = + _runtime.bodySerDe().serializer(new TypeMarker>() {}); + + private final EndpointChannel testMultipleErrorsAndPackagesChannel = + _endpointChannelFactory.endpoint(DialogueErrorEndpoints.testMultipleErrorsAndPackages); + + private final Deserializer + testMultipleErrorsAndPackagesDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .error( + TestErrors.INVALID_ARGUMENT.name(), + new TypeMarker() {}) + .error( + TestErrors.NOT_FOUND.name(), + new TypeMarker() {}) + .error( + EndpointSpecificTwoErrors.DIFFERENT_NAMESPACE.name(), + new TypeMarker< + TestMultipleErrorsAndPackagesResponse.DifferentNamespace>() {}) + .error( + dialogueendpointresulttypes.com.palantir.another.EndpointSpecificErrors + .DIFFERENT_PACKAGE + .name(), + new TypeMarker() {}) + .error( + TestErrors.COMPLICATED_PARAMETERS.name(), + new TypeMarker< + TestMultipleErrorsAndPackagesResponse.ComplicatedParameters>() {}) + .build()); + + private final Serializer testEmptyBodySerializer = + _runtime.bodySerDe().serializer(new TypeMarker() {}); + + private final EndpointChannel testEmptyBodyChannel = + _endpointChannelFactory.endpoint(DialogueErrorEndpoints.testEmptyBody); + + private final Deserializer testEmptyBodyDeserializer = _runtime.bodySerDe() + .deserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .error( + TestErrors.INVALID_ARGUMENT.name(), + new TypeMarker() {}) + .build()); + + private final Serializer testBinarySerializer = + _runtime.bodySerDe().serializer(new TypeMarker() {}); + + private final EndpointChannel testBinaryChannel = + _endpointChannelFactory.endpoint(DialogueErrorEndpoints.testBinary); + + private final Deserializer testBinaryDeserializer = _runtime.bodySerDe() + .inputStreamDeserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .error( + TestErrors.INVALID_ARGUMENT.name(), + new TypeMarker() {}) + .build()); + + private final Serializer testOptionalBinarySerializer = + _runtime.bodySerDe().serializer(new TypeMarker() {}); + + private final EndpointChannel testOptionalBinaryChannel = + _endpointChannelFactory.endpoint(DialogueErrorEndpoints.testOptionalBinary); + + private final Deserializer testOptionalBinaryDeserializer = _runtime.bodySerDe() + .optionalInputStreamDeserializer(DeserializerArgs.builder() + .baseType(new TypeMarker<>() {}) + .success(new TypeMarker() {}) + .error( + TestErrors.INVALID_ARGUMENT.name(), + new TypeMarker() {}) + .build()); + + @Override + public TestBasicErrorResponse testBasicError(AuthHeader authHeader, boolean shouldThrowError) { + Request.Builder _request = Request.builder(); + _request.putHeaderParams("Authorization", authHeader.toString()); + _request.body(testBasicErrorSerializer.serialize(shouldThrowError)); + return _runtime.clients() + .callBlocking(testBasicErrorChannel, _request.build(), testBasicErrorDeserializer); + } + + @Override + public TestImportedErrorResponse testImportedError(AuthHeader authHeader, boolean shouldThrowError) { + Request.Builder _request = Request.builder(); + _request.putHeaderParams("Authorization", authHeader.toString()); + _request.body(testImportedErrorSerializer.serialize(shouldThrowError)); + return _runtime.clients() + .callBlocking(testImportedErrorChannel, _request.build(), testImportedErrorDeserializer); + } + + @Override + public TestMultipleErrorsAndPackagesResponse testMultipleErrorsAndPackages( + AuthHeader authHeader, Optional errorToThrow) { + Request.Builder _request = Request.builder(); + _request.putHeaderParams("Authorization", authHeader.toString()); + _request.body(testMultipleErrorsAndPackagesSerializer.serialize(errorToThrow)); + return _runtime.clients() + .callBlocking( + testMultipleErrorsAndPackagesChannel, + _request.build(), + testMultipleErrorsAndPackagesDeserializer); + } + + @Override + public TestEmptyBodyResponse testEmptyBody(AuthHeader authHeader, boolean shouldThrowError) { + Request.Builder _request = Request.builder(); + _request.putHeaderParams("Authorization", authHeader.toString()); + _request.body(testEmptyBodySerializer.serialize(shouldThrowError)); + return _runtime.clients() + .callBlocking(testEmptyBodyChannel, _request.build(), testEmptyBodyDeserializer); + } + + @Override + public TestBinaryResponse testBinary(AuthHeader authHeader, boolean shouldThrowError) { + Request.Builder _request = Request.builder(); + _request.putHeaderParams("Authorization", authHeader.toString()); + _request.body(testBinarySerializer.serialize(shouldThrowError)); + return _runtime.clients().callBlocking(testBinaryChannel, _request.build(), testBinaryDeserializer); + } + + @Override + public TestOptionalBinaryResponse testOptionalBinary( + AuthHeader authHeader, OptionalBinaryResponseMode mode) { + Request.Builder _request = Request.builder(); + _request.putHeaderParams("Authorization", authHeader.toString()); + _request.body(testOptionalBinarySerializer.serialize(mode)); + return _runtime.clients() + .callBlocking(testOptionalBinaryChannel, _request.build(), testOptionalBinaryDeserializer); + } + + @Override + public String toString() { + return "ErrorServiceBlocking{_endpointChannelFactory=" + _endpointChannelFactory + ", runtime=" + + _runtime + '}'; + } + }; + } + + /** Creates an asynchronous/non-blocking client for a ErrorService service. */ + static ErrorServiceBlocking of(Channel _channel, ConjureRuntime _runtime) { + if (_channel instanceof EndpointChannelFactory) { + return of((EndpointChannelFactory) _channel, _runtime); + } + return of( + new EndpointChannelFactory() { + @Override + public EndpointChannel endpoint(Endpoint endpoint) { + return _runtime.clients().bind(_channel, endpoint); + } + }, + _runtime); + } + + final class Factory implements DialogueServiceFactory { + @Override + public ErrorServiceBlocking create(EndpointChannelFactory endpointChannelFactory, ConjureRuntime runtime) { + return ErrorServiceBlocking.of(endpointChannelFactory, runtime); + } + } + + sealed interface TestBasicErrorResponse + permits TestBasicErrorResponse.Success, + TestBasicErrorResponse.InvalidArgument, + TestBasicErrorResponse.ConflictingCauseSafeArgErr { + record Success(@JsonValue String value) implements TestBasicErrorResponse { + public Success { + Preconditions.checkArgumentNotNull(value, "value cannot be null"); + } + } + + final class InvalidArgument extends EndpointError + implements TestBasicErrorResponse { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + InvalidArgument( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") TestErrors.InvalidArgumentParameters parameters) { + super(errorCode, TestErrors.INVALID_ARGUMENT.name(), errorInstanceId, parameters); + } + } + + final class ConflictingCauseSafeArgErr extends EndpointError + implements TestBasicErrorResponse { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + ConflictingCauseSafeArgErr( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") ConjureErrors.ConflictingCauseSafeArgErrParameters parameters) { + super(errorCode, ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG_ERR.name(), errorInstanceId, parameters); + } + } + } + + sealed interface TestImportedErrorResponse + permits TestImportedErrorResponse.Success, TestImportedErrorResponse.EndpointError { + record Success(@JsonValue String value) implements TestImportedErrorResponse { + public Success { + Preconditions.checkArgumentNotNull(value, "value cannot be null"); + } + } + + final class EndpointError + extends com.palantir.dialogue.EndpointError + implements TestImportedErrorResponse { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + EndpointError( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") EndpointSpecificErrors.EndpointErrorParameters parameters) { + super(errorCode, EndpointSpecificErrors.ENDPOINT_ERROR.name(), errorInstanceId, parameters); + } + } + } + + sealed interface TestMultipleErrorsAndPackagesResponse + permits TestMultipleErrorsAndPackagesResponse.Success, + TestMultipleErrorsAndPackagesResponse.InvalidArgument, + TestMultipleErrorsAndPackagesResponse.NotFound, + TestMultipleErrorsAndPackagesResponse.DifferentNamespace, + TestMultipleErrorsAndPackagesResponse.DifferentPackage, + TestMultipleErrorsAndPackagesResponse.ComplicatedParameters { + record Success(@JsonValue String value) implements TestMultipleErrorsAndPackagesResponse { + public Success { + Preconditions.checkArgumentNotNull(value, "value cannot be null"); + } + } + + final class InvalidArgument extends EndpointError + implements TestMultipleErrorsAndPackagesResponse { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + InvalidArgument( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") TestErrors.InvalidArgumentParameters parameters) { + super(errorCode, TestErrors.INVALID_ARGUMENT.name(), errorInstanceId, parameters); + } + } + + final class NotFound extends EndpointError + implements TestMultipleErrorsAndPackagesResponse { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + NotFound( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") TestErrors.NotFoundParameters parameters) { + super(errorCode, TestErrors.NOT_FOUND.name(), errorInstanceId, parameters); + } + } + + final class DifferentNamespace extends EndpointError + implements TestMultipleErrorsAndPackagesResponse { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + DifferentNamespace( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId) { + super( + errorCode, + EndpointSpecificTwoErrors.DIFFERENT_NAMESPACE.name(), + errorInstanceId, + new EndpointSpecificTwoErrors.DifferentNamespaceParameters()); + } + } + + final class DifferentPackage + extends EndpointError< + dialogueendpointresulttypes.com.palantir.another.EndpointSpecificErrors + .DifferentPackageParameters> + implements TestMultipleErrorsAndPackagesResponse { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + DifferentPackage( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId) { + super( + errorCode, + dialogueendpointresulttypes.com.palantir.another.EndpointSpecificErrors.DIFFERENT_PACKAGE + .name(), + errorInstanceId, + new dialogueendpointresulttypes.com.palantir.another.EndpointSpecificErrors + .DifferentPackageParameters()); + } + } + + final class ComplicatedParameters extends EndpointError + implements TestMultipleErrorsAndPackagesResponse { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + ComplicatedParameters( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") TestErrors.ComplicatedParametersParameters parameters) { + super(errorCode, TestErrors.COMPLICATED_PARAMETERS.name(), errorInstanceId, parameters); + } + } + } + + sealed interface TestEmptyBodyResponse + permits TestEmptyBodyResponse.Success, TestEmptyBodyResponse.InvalidArgument { + record Success() implements TestEmptyBodyResponse {} + + final class InvalidArgument extends EndpointError + implements TestEmptyBodyResponse { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + InvalidArgument( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") TestErrors.InvalidArgumentParameters parameters) { + super(errorCode, TestErrors.INVALID_ARGUMENT.name(), errorInstanceId, parameters); + } + } + } + + sealed interface TestBinaryResponse extends Closeable + permits TestBinaryResponse.Success, TestBinaryResponse.InvalidArgument { + @Override + default void close() throws IOException {} + + record Success(@MustBeClosed @JsonValue InputStream value) implements TestBinaryResponse { + public Success { + Preconditions.checkArgumentNotNull(value, "value cannot be null"); + } + + @Override + public void close() throws IOException { + value.close(); + } + } + + final class InvalidArgument extends EndpointError + implements TestBinaryResponse { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + InvalidArgument( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") TestErrors.InvalidArgumentParameters parameters) { + super(errorCode, TestErrors.INVALID_ARGUMENT.name(), errorInstanceId, parameters); + } + } + } + + sealed interface TestOptionalBinaryResponse extends Closeable + permits TestOptionalBinaryResponse.Success, TestOptionalBinaryResponse.InvalidArgument { + @Override + default void close() throws IOException {} + + record Success(@JsonValue Optional value) implements TestOptionalBinaryResponse { + public Success { + Preconditions.checkArgumentNotNull(value, "value cannot be null"); + } + + @Override + public void close() throws IOException { + if (value.isPresent()) { + value.get().close(); + } + } + } + + final class InvalidArgument extends EndpointError + implements TestOptionalBinaryResponse { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + InvalidArgument( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") TestErrors.InvalidArgumentParameters parameters) { + super(errorCode, TestErrors.INVALID_ARGUMENT.name(), errorInstanceId, parameters); + } + } + } +} diff --git a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorServiceEndpoints.java b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorServiceEndpoints.java new file mode 100644 index 000000000..e4a94ff84 --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorServiceEndpoints.java @@ -0,0 +1,345 @@ +package dialogueendpointresulttypes.com.palantir.product; + +import com.google.common.collect.ImmutableList; +import com.palantir.conjure.java.undertow.lib.BinaryResponseBody; +import com.palantir.conjure.java.undertow.lib.Deserializer; +import com.palantir.conjure.java.undertow.lib.Endpoint; +import com.palantir.conjure.java.undertow.lib.Serializer; +import com.palantir.conjure.java.undertow.lib.TypeMarker; +import com.palantir.conjure.java.undertow.lib.UndertowRuntime; +import com.palantir.conjure.java.undertow.lib.UndertowService; +import com.palantir.tokens.auth.AuthHeader; +import io.undertow.server.HttpHandler; +import io.undertow.server.HttpServerExchange; +import io.undertow.util.HttpString; +import io.undertow.util.Methods; +import io.undertow.util.StatusCodes; +import java.io.IOException; +import java.util.List; +import java.util.Optional; +import javax.annotation.processing.Generated; + +@Generated("com.palantir.conjure.java.services.UndertowServiceHandlerGenerator") +public final class ErrorServiceEndpoints implements UndertowService { + private final ErrorService delegate; + + private ErrorServiceEndpoints(ErrorService delegate) { + this.delegate = delegate; + } + + public static UndertowService of(ErrorService delegate) { + return new ErrorServiceEndpoints(delegate); + } + + @Override + public List endpoints(UndertowRuntime runtime) { + return ImmutableList.of( + new TestBasicErrorEndpoint(runtime, delegate), + new TestImportedErrorEndpoint(runtime, delegate), + new TestMultipleErrorsAndPackagesEndpoint(runtime, delegate), + new TestEmptyBodyEndpoint(runtime, delegate), + new TestBinaryEndpoint(runtime, delegate), + new TestOptionalBinaryEndpoint(runtime, delegate)); + } + + private static final class TestBasicErrorEndpoint implements HttpHandler, Endpoint { + private final UndertowRuntime runtime; + + private final ErrorService delegate; + + private final Deserializer deserializer; + + private final Serializer serializer; + + TestBasicErrorEndpoint(UndertowRuntime runtime, ErrorService delegate) { + this.runtime = runtime; + this.delegate = delegate; + this.deserializer = runtime.bodySerDe().deserializer(new TypeMarker() {}, this); + this.serializer = runtime.bodySerDe().serializer(new TypeMarker() {}, this); + } + + @Override + public void handleRequest(HttpServerExchange exchange) + throws IOException, TestServerErrors.InvalidArgument, ConjureServerErrors.ConflictingCauseSafeArgErr { + AuthHeader authHeader = runtime.auth().header(exchange); + Boolean shouldThrowError = deserializer.deserialize(exchange); + String result = delegate.testBasicError(authHeader, shouldThrowError); + serializer.serialize(result, exchange); + } + + @Override + public HttpString method() { + return Methods.POST; + } + + @Override + public String template() { + return "/errors/basic"; + } + + @Override + public String serviceName() { + return "ErrorService"; + } + + @Override + public String name() { + return "testBasicError"; + } + + @Override + public HttpHandler handler() { + return this; + } + } + + private static final class TestImportedErrorEndpoint implements HttpHandler, Endpoint { + private final UndertowRuntime runtime; + + private final ErrorService delegate; + + private final Deserializer deserializer; + + private final Serializer serializer; + + TestImportedErrorEndpoint(UndertowRuntime runtime, ErrorService delegate) { + this.runtime = runtime; + this.delegate = delegate; + this.deserializer = runtime.bodySerDe().deserializer(new TypeMarker() {}, this); + this.serializer = runtime.bodySerDe().serializer(new TypeMarker() {}, this); + } + + @Override + public void handleRequest(HttpServerExchange exchange) + throws IOException, EndpointSpecificServerErrors.EndpointError { + AuthHeader authHeader = runtime.auth().header(exchange); + Boolean shouldThrowError = deserializer.deserialize(exchange); + String result = delegate.testImportedError(authHeader, shouldThrowError); + serializer.serialize(result, exchange); + } + + @Override + public HttpString method() { + return Methods.POST; + } + + @Override + public String template() { + return "/errors/imported"; + } + + @Override + public String serviceName() { + return "ErrorService"; + } + + @Override + public String name() { + return "testImportedError"; + } + + @Override + public HttpHandler handler() { + return this; + } + } + + private static final class TestMultipleErrorsAndPackagesEndpoint implements HttpHandler, Endpoint { + private final UndertowRuntime runtime; + + private final ErrorService delegate; + + private final Deserializer> deserializer; + + private final Serializer serializer; + + TestMultipleErrorsAndPackagesEndpoint(UndertowRuntime runtime, ErrorService delegate) { + this.runtime = runtime; + this.delegate = delegate; + this.deserializer = runtime.bodySerDe().deserializer(new TypeMarker>() {}, this); + this.serializer = runtime.bodySerDe().serializer(new TypeMarker() {}, this); + } + + @Override + public void handleRequest(HttpServerExchange exchange) + throws IOException, TestServerErrors.InvalidArgument, TestServerErrors.NotFound, + EndpointSpecificTwoServerErrors.DifferentNamespace, + dialogueendpointresulttypes.com.palantir.another.EndpointSpecificServerErrors.DifferentPackage, + TestServerErrors.ComplicatedParameters { + AuthHeader authHeader = runtime.auth().header(exchange); + Optional errorToThrow = deserializer.deserialize(exchange); + String result = delegate.testMultipleErrorsAndPackages(authHeader, errorToThrow); + serializer.serialize(result, exchange); + } + + @Override + public HttpString method() { + return Methods.POST; + } + + @Override + public String template() { + return "/errors/multiple"; + } + + @Override + public String serviceName() { + return "ErrorService"; + } + + @Override + public String name() { + return "testMultipleErrorsAndPackages"; + } + + @Override + public HttpHandler handler() { + return this; + } + } + + private static final class TestEmptyBodyEndpoint implements HttpHandler, Endpoint { + private final UndertowRuntime runtime; + + private final ErrorService delegate; + + private final Deserializer deserializer; + + TestEmptyBodyEndpoint(UndertowRuntime runtime, ErrorService delegate) { + this.runtime = runtime; + this.delegate = delegate; + this.deserializer = runtime.bodySerDe().deserializer(new TypeMarker() {}, this); + } + + @Override + public void handleRequest(HttpServerExchange exchange) throws IOException, TestServerErrors.InvalidArgument { + AuthHeader authHeader = runtime.auth().header(exchange); + Boolean shouldThrowError = deserializer.deserialize(exchange); + delegate.testEmptyBody(authHeader, shouldThrowError); + exchange.setStatusCode(StatusCodes.NO_CONTENT); + } + + @Override + public HttpString method() { + return Methods.POST; + } + + @Override + public String template() { + return "/errors/empty"; + } + + @Override + public String serviceName() { + return "ErrorService"; + } + + @Override + public String name() { + return "testEmptyBody"; + } + + @Override + public HttpHandler handler() { + return this; + } + } + + private static final class TestBinaryEndpoint implements HttpHandler, Endpoint { + private final UndertowRuntime runtime; + + private final ErrorService delegate; + + private final Deserializer deserializer; + + TestBinaryEndpoint(UndertowRuntime runtime, ErrorService delegate) { + this.runtime = runtime; + this.delegate = delegate; + this.deserializer = runtime.bodySerDe().deserializer(new TypeMarker() {}, this); + } + + @Override + public void handleRequest(HttpServerExchange exchange) throws IOException, TestServerErrors.InvalidArgument { + AuthHeader authHeader = runtime.auth().header(exchange); + Boolean shouldThrowError = deserializer.deserialize(exchange); + BinaryResponseBody result = delegate.testBinary(authHeader, shouldThrowError); + runtime.bodySerDe().serialize(result, exchange); + } + + @Override + public HttpString method() { + return Methods.POST; + } + + @Override + public String template() { + return "/errors/binary"; + } + + @Override + public String serviceName() { + return "ErrorService"; + } + + @Override + public String name() { + return "testBinary"; + } + + @Override + public HttpHandler handler() { + return this; + } + } + + private static final class TestOptionalBinaryEndpoint implements HttpHandler, Endpoint { + private final UndertowRuntime runtime; + + private final ErrorService delegate; + + private final Deserializer deserializer; + + TestOptionalBinaryEndpoint(UndertowRuntime runtime, ErrorService delegate) { + this.runtime = runtime; + this.delegate = delegate; + this.deserializer = runtime.bodySerDe().deserializer(new TypeMarker() {}, this); + } + + @Override + public void handleRequest(HttpServerExchange exchange) throws IOException, TestServerErrors.InvalidArgument { + AuthHeader authHeader = runtime.auth().header(exchange); + OptionalBinaryResponseMode mode = deserializer.deserialize(exchange); + Optional result = delegate.testOptionalBinary(authHeader, mode); + if (result.isPresent()) { + runtime.bodySerDe().serialize(result.get(), exchange); + } else { + exchange.setStatusCode(StatusCodes.NO_CONTENT); + } + } + + @Override + public HttpString method() { + return Methods.POST; + } + + @Override + public String template() { + return "/errors/optional-binary"; + } + + @Override + public String serviceName() { + return "ErrorService"; + } + + @Override + public String name() { + return "testOptionalBinary"; + } + + @Override + public HttpHandler handler() { + return this; + } + } +} diff --git a/conjure-java-core/src/integrationInput/java/errors/com/palantir/another/ConjureErrors.java b/conjure-java-core/src/integrationInput/java/errors/com/palantir/another/ConjureErrors.java index 92219a91d..22650c204 100644 --- a/conjure-java-core/src/integrationInput/java/errors/com/palantir/another/ConjureErrors.java +++ b/conjure-java-core/src/integrationInput/java/errors/com/palantir/another/ConjureErrors.java @@ -47,16 +47,16 @@ public static boolean isDifferentPackageError(RemoteException remoteException) { return DIFFERENT_PACKAGE_ERROR.name().equals(remoteException.getError().errorName()); } - public static record DifferentPackageParameters() {} + public static record DifferentPackageErrParameters() {} - public static final class DifferentPackageSerializableError - extends AbstractSerializableError { + public static final class DifferentPackageErrSerializableError + extends AbstractSerializableError { @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - DifferentPackageSerializableError( + DifferentPackageErrSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") DifferentPackageParameters parameters) { + @JsonProperty("parameters") DifferentPackageErrParameters parameters) { super(errorCode, errorName, errorInstanceId, parameters); } @@ -69,18 +69,18 @@ public SerializableError toSerializableError() { } } - public static final class DifferentPackageException extends RemoteException { - private DifferentPackageSerializableError error; + public static final class DifferentPackageErrException extends RemoteException { + private DifferentPackageErrSerializableError error; private int status; - public DifferentPackageException(DifferentPackageSerializableError error, int status) { + public DifferentPackageErrException(DifferentPackageErrSerializableError error, int status) { super(error.toSerializableError(), status); this.error = error; this.status = status; } - public DifferentPackageSerializableError error() { + public DifferentPackageErrSerializableError error() { return error; } } diff --git a/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureErrors.java b/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureErrors.java index 97c7ebf61..b1290939c 100644 --- a/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureErrors.java +++ b/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureErrors.java @@ -350,7 +350,7 @@ public static record ErrorWithComplexArgsParameters( @JsonProperty("objectReference") @Safe ObjectReference objectReference, @JsonProperty("unionExample") @Safe UnionExample unionExample, @JsonProperty("enumExample") @Safe EnumExample enumExample, - @JsonProperty("stringAlias") @Safe StringAlias stringAlias, + @JsonProperty("stringAlias") @Safe StringAliasEx stringAlias, @JsonProperty("optionalAlias") @Safe OptionalAlias optionalAlias, @JsonProperty("collectionAlias") @Safe CollectionAlias collectionAlias, @JsonProperty("nestedAlias") @Safe NestedAlias nestedAlias, diff --git a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/AnyExample.java b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/AnyExample.java new file mode 100644 index 000000000..d8c7c2800 --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/AnyExample.java @@ -0,0 +1,162 @@ +package jersey.com.palantir.product; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonSetter; +import com.fasterxml.jackson.annotation.Nulls; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import com.google.errorprone.annotations.CheckReturnValue; +import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.SafeArg; +import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; +import java.util.ArrayList; +import java.util.Collections; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import javax.annotation.processing.Generated; + +@JsonDeserialize(builder = AnyExample.Builder.class) +@Generated("com.palantir.conjure.java.types.BeanGenerator") +public final class AnyExample { + private final Object anyValue; + + private final Map anyMap; + + private int memoizedHashCode; + + private AnyExample(Object anyValue, Map anyMap) { + validateFields(anyValue, anyMap); + this.anyValue = anyValue; + this.anyMap = Collections.unmodifiableMap(anyMap); + } + + @JsonProperty("anyValue") + public Object getAnyValue() { + return this.anyValue; + } + + @JsonProperty("anyMap") + public Map getAnyMap() { + return this.anyMap; + } + + @Override + public boolean equals(@Nullable Object other) { + return this == other || (other instanceof AnyExample && equalTo((AnyExample) other)); + } + + private boolean equalTo(AnyExample other) { + if (this.memoizedHashCode != 0 + && other.memoizedHashCode != 0 + && this.memoizedHashCode != other.memoizedHashCode) { + return false; + } + return this.anyValue.equals(other.anyValue) && this.anyMap.equals(other.anyMap); + } + + @Override + public int hashCode() { + int result = memoizedHashCode; + if (result == 0) { + int hash = 1; + hash = 31 * hash + this.anyValue.hashCode(); + hash = 31 * hash + this.anyMap.hashCode(); + result = hash; + memoizedHashCode = result; + } + return result; + } + + @Override + public String toString() { + return "AnyExample{anyValue: " + anyValue + ", anyMap: " + anyMap + '}'; + } + + public static AnyExample of(Object anyValue, Map anyMap) { + return builder().anyValue(anyValue).anyMap(anyMap).build(); + } + + private static void validateFields(Object anyValue, Map anyMap) { + List missingFields = null; + missingFields = addFieldIfMissing(missingFields, anyValue, "anyValue"); + missingFields = addFieldIfMissing(missingFields, anyMap, "anyMap"); + if (missingFields != null) { + throw new SafeIllegalArgumentException( + "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); + } + } + + private static List addFieldIfMissing(List prev, Object fieldValue, String fieldName) { + List missingFields = prev; + if (fieldValue == null) { + if (missingFields == null) { + missingFields = new ArrayList<>(2); + } + missingFields.add(fieldName); + } + return missingFields; + } + + public static Builder builder() { + return new Builder(); + } + + @Generated("com.palantir.conjure.java.types.BeanBuilderGenerator") + @JsonIgnoreProperties(ignoreUnknown = true) + public static final class Builder { + boolean _buildInvoked; + + private Object anyValue; + + private Map anyMap = new LinkedHashMap<>(); + + private Builder() {} + + public Builder from(AnyExample other) { + checkNotBuilt(); + anyValue(other.getAnyValue()); + anyMap(other.getAnyMap()); + return this; + } + + @JsonSetter("anyValue") + public Builder anyValue(@Nonnull Object anyValue) { + checkNotBuilt(); + this.anyValue = Preconditions.checkNotNull(anyValue, "anyValue cannot be null"); + return this; + } + + @JsonSetter(value = "anyMap", nulls = Nulls.SKIP) + public Builder anyMap(@Nonnull Map anyMap) { + checkNotBuilt(); + this.anyMap = new LinkedHashMap<>(Preconditions.checkNotNull(anyMap, "anyMap cannot be null")); + return this; + } + + public Builder putAllAnyMap(@Nonnull Map anyMap) { + checkNotBuilt(); + this.anyMap.putAll(Preconditions.checkNotNull(anyMap, "anyMap cannot be null")); + return this; + } + + public Builder anyMap(String key, Object value) { + checkNotBuilt(); + this.anyMap.put(key, value); + return this; + } + + @CheckReturnValue + public AnyExample build() { + checkNotBuilt(); + this._buildInvoked = true; + return new AnyExample(anyValue, anyMap); + } + + private void checkNotBuilt() { + Preconditions.checkState(!_buildInvoked, "Build has already been called"); + } + } +} diff --git a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/CollectionAlias.java b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/CollectionAlias.java new file mode 100644 index 000000000..1e9d469f9 --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/CollectionAlias.java @@ -0,0 +1,70 @@ +package jersey.com.palantir.product; + +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonValue; +import com.palantir.logsafe.Preconditions; +import java.util.Collections; +import java.util.List; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import javax.annotation.processing.Generated; + +@Generated("com.palantir.conjure.java.types.AliasGenerator") +public final class CollectionAlias { + private static final CollectionAlias EMPTY = new CollectionAlias(); + + private final List value; + + private int memoizedHashCode; + + private CollectionAlias(@Nonnull List value) { + this.value = Preconditions.checkNotNull(value, "value cannot be null"); + } + + private CollectionAlias() { + this(Collections.emptyList()); + } + + @JsonValue + public List get() { + return value; + } + + @Override + public String toString() { + return value.toString(); + } + + @Override + public boolean equals(@Nullable Object other) { + return this == other || (other instanceof CollectionAlias && equalTo((CollectionAlias) other)); + } + + private boolean equalTo(CollectionAlias other) { + if (this.memoizedHashCode != 0 + && other.memoizedHashCode != 0 + && this.memoizedHashCode != other.memoizedHashCode) { + return false; + } + return this.value.equals(other.value); + } + + @Override + public int hashCode() { + int result = memoizedHashCode; + if (result == 0) { + result = this.value.hashCode(); + memoizedHashCode = result; + } + return result; + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static CollectionAlias of(@Nonnull List value) { + return new CollectionAlias(value); + } + + public static CollectionAlias empty() { + return EMPTY; + } +} diff --git a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/CollectionExample.java b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/CollectionExample.java new file mode 100644 index 000000000..1f4162545 --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/CollectionExample.java @@ -0,0 +1,219 @@ +package jersey.com.palantir.product; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonSetter; +import com.fasterxml.jackson.annotation.Nulls; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import com.google.errorprone.annotations.CheckReturnValue; +import com.palantir.conjure.java.lib.internal.ConjureCollections; +import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.SafeArg; +import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; +import java.util.ArrayList; +import java.util.Collections; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import javax.annotation.processing.Generated; + +@JsonDeserialize(builder = CollectionExample.Builder.class) +@Generated("com.palantir.conjure.java.types.BeanGenerator") +public final class CollectionExample { + private final List stringList; + + private final Set stringSet; + + private final Map stringMap; + + private int memoizedHashCode; + + private CollectionExample(List stringList, Set stringSet, Map stringMap) { + validateFields(stringList, stringSet, stringMap); + this.stringList = ConjureCollections.unmodifiableList(stringList); + this.stringSet = Collections.unmodifiableSet(stringSet); + this.stringMap = Collections.unmodifiableMap(stringMap); + } + + @JsonProperty("stringList") + public List getStringList() { + return this.stringList; + } + + @JsonProperty("stringSet") + public Set getStringSet() { + return this.stringSet; + } + + @JsonProperty("stringMap") + public Map getStringMap() { + return this.stringMap; + } + + @Override + public boolean equals(@Nullable Object other) { + return this == other || (other instanceof CollectionExample && equalTo((CollectionExample) other)); + } + + private boolean equalTo(CollectionExample other) { + if (this.memoizedHashCode != 0 + && other.memoizedHashCode != 0 + && this.memoizedHashCode != other.memoizedHashCode) { + return false; + } + return this.stringList.equals(other.stringList) + && this.stringSet.equals(other.stringSet) + && this.stringMap.equals(other.stringMap); + } + + @Override + public int hashCode() { + int result = memoizedHashCode; + if (result == 0) { + int hash = 1; + hash = 31 * hash + this.stringList.hashCode(); + hash = 31 * hash + this.stringSet.hashCode(); + hash = 31 * hash + this.stringMap.hashCode(); + result = hash; + memoizedHashCode = result; + } + return result; + } + + @Override + public String toString() { + return "CollectionExample{stringList: " + stringList + ", stringSet: " + stringSet + ", stringMap: " + stringMap + + '}'; + } + + public static CollectionExample of(List stringList, Set stringSet, Map stringMap) { + return builder() + .stringList(stringList) + .stringSet(stringSet) + .stringMap(stringMap) + .build(); + } + + private static void validateFields(List stringList, Set stringSet, Map stringMap) { + List missingFields = null; + missingFields = addFieldIfMissing(missingFields, stringList, "stringList"); + missingFields = addFieldIfMissing(missingFields, stringSet, "stringSet"); + missingFields = addFieldIfMissing(missingFields, stringMap, "stringMap"); + if (missingFields != null) { + throw new SafeIllegalArgumentException( + "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); + } + } + + private static List addFieldIfMissing(List prev, Object fieldValue, String fieldName) { + List missingFields = prev; + if (fieldValue == null) { + if (missingFields == null) { + missingFields = new ArrayList<>(3); + } + missingFields.add(fieldName); + } + return missingFields; + } + + public static Builder builder() { + return new Builder(); + } + + @Generated("com.palantir.conjure.java.types.BeanBuilderGenerator") + @JsonIgnoreProperties(ignoreUnknown = true) + public static final class Builder { + boolean _buildInvoked; + + private List stringList = ConjureCollections.newList(); + + private Set stringSet = ConjureCollections.newSet(); + + private Map stringMap = new LinkedHashMap<>(); + + private Builder() {} + + public Builder from(CollectionExample other) { + checkNotBuilt(); + stringList(other.getStringList()); + stringSet(other.getStringSet()); + stringMap(other.getStringMap()); + return this; + } + + @JsonSetter(value = "stringList", nulls = Nulls.SKIP) + public Builder stringList(@Nonnull Iterable stringList) { + checkNotBuilt(); + this.stringList = + ConjureCollections.newList(Preconditions.checkNotNull(stringList, "stringList cannot be null")); + return this; + } + + public Builder addAllStringList(@Nonnull Iterable stringList) { + checkNotBuilt(); + ConjureCollections.addAll( + this.stringList, Preconditions.checkNotNull(stringList, "stringList cannot be null")); + return this; + } + + public Builder stringList(String stringList) { + checkNotBuilt(); + this.stringList.add(stringList); + return this; + } + + @JsonSetter(value = "stringSet", nulls = Nulls.SKIP) + public Builder stringSet(@Nonnull Iterable stringSet) { + checkNotBuilt(); + this.stringSet = + ConjureCollections.newSet(Preconditions.checkNotNull(stringSet, "stringSet cannot be null")); + return this; + } + + public Builder addAllStringSet(@Nonnull Iterable stringSet) { + checkNotBuilt(); + ConjureCollections.addAll( + this.stringSet, Preconditions.checkNotNull(stringSet, "stringSet cannot be null")); + return this; + } + + public Builder stringSet(String stringSet) { + checkNotBuilt(); + this.stringSet.add(stringSet); + return this; + } + + @JsonSetter(value = "stringMap", nulls = Nulls.SKIP) + public Builder stringMap(@Nonnull Map stringMap) { + checkNotBuilt(); + this.stringMap = new LinkedHashMap<>(Preconditions.checkNotNull(stringMap, "stringMap cannot be null")); + return this; + } + + public Builder putAllStringMap(@Nonnull Map stringMap) { + checkNotBuilt(); + this.stringMap.putAll(Preconditions.checkNotNull(stringMap, "stringMap cannot be null")); + return this; + } + + public Builder stringMap(String key, String value) { + checkNotBuilt(); + this.stringMap.put(key, value); + return this; + } + + @CheckReturnValue + public CollectionExample build() { + checkNotBuilt(); + this._buildInvoked = true; + return new CollectionExample(stringList, stringSet, stringMap); + } + + private void checkNotBuilt() { + Preconditions.checkState(!_buildInvoked, "Build has already been called"); + } + } +} diff --git a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/ComplexExample.java b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/ComplexExample.java new file mode 100644 index 000000000..adcfa6e29 --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/ComplexExample.java @@ -0,0 +1,232 @@ +package jersey.com.palantir.product; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonSetter; +import com.fasterxml.jackson.annotation.Nulls; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import com.google.errorprone.annotations.CheckReturnValue; +import com.palantir.conjure.java.lib.internal.ConjureCollections; +import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.SafeArg; +import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; +import java.util.ArrayList; +import java.util.Collections; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.function.Function; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import javax.annotation.processing.Generated; + +@JsonDeserialize(builder = ComplexExample.Builder.class) +@Generated("com.palantir.conjure.java.types.BeanGenerator") +public final class ComplexExample { + private final Map>> metadata; + + private final EnumExample status; + + private final List variants; + + private final Optional external; + + private int memoizedHashCode; + + private ComplexExample( + Map>> metadata, + EnumExample status, + List variants, + Optional external) { + validateFields(metadata, status, variants, external); + this.metadata = Collections.unmodifiableMap(metadata); + this.status = status; + this.variants = ConjureCollections.unmodifiableList(variants); + this.external = external; + } + + @JsonProperty("metadata") + public Map>> getMetadata() { + return this.metadata; + } + + @JsonProperty("status") + public EnumExample getStatus() { + return this.status; + } + + @JsonProperty("variants") + public List getVariants() { + return this.variants; + } + + @JsonProperty("external") + public Optional getExternal() { + return this.external; + } + + @Override + public boolean equals(@Nullable Object other) { + return this == other || (other instanceof ComplexExample && equalTo((ComplexExample) other)); + } + + private boolean equalTo(ComplexExample other) { + if (this.memoizedHashCode != 0 + && other.memoizedHashCode != 0 + && this.memoizedHashCode != other.memoizedHashCode) { + return false; + } + return this.metadata.equals(other.metadata) + && this.status.equals(other.status) + && this.variants.equals(other.variants) + && this.external.equals(other.external); + } + + @Override + public int hashCode() { + int result = memoizedHashCode; + if (result == 0) { + int hash = 1; + hash = 31 * hash + this.metadata.hashCode(); + hash = 31 * hash + this.status.hashCode(); + hash = 31 * hash + this.variants.hashCode(); + hash = 31 * hash + this.external.hashCode(); + result = hash; + memoizedHashCode = result; + } + return result; + } + + @Override + public String toString() { + return "ComplexExample{metadata: " + metadata + ", status: " + status + ", variants: " + variants + + ", external: " + external + '}'; + } + + private static void validateFields( + Map>> metadata, + EnumExample status, + List variants, + Optional external) { + List missingFields = null; + missingFields = addFieldIfMissing(missingFields, metadata, "metadata"); + missingFields = addFieldIfMissing(missingFields, status, "status"); + missingFields = addFieldIfMissing(missingFields, variants, "variants"); + missingFields = addFieldIfMissing(missingFields, external, "external"); + if (missingFields != null) { + throw new SafeIllegalArgumentException( + "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); + } + } + + private static List addFieldIfMissing(List prev, Object fieldValue, String fieldName) { + List missingFields = prev; + if (fieldValue == null) { + if (missingFields == null) { + missingFields = new ArrayList<>(4); + } + missingFields.add(fieldName); + } + return missingFields; + } + + public static Builder builder() { + return new Builder(); + } + + @Generated("com.palantir.conjure.java.types.BeanBuilderGenerator") + @JsonIgnoreProperties(ignoreUnknown = true) + public static final class Builder { + boolean _buildInvoked; + + private Map>> metadata = new LinkedHashMap<>(); + + private EnumExample status; + + private List variants = ConjureCollections.newList(); + + private Optional external = Optional.empty(); + + private Builder() {} + + public Builder from(ComplexExample other) { + checkNotBuilt(); + metadata(other.getMetadata()); + status(other.getStatus()); + variants(other.getVariants()); + external(other.getExternal()); + return this; + } + + @JsonSetter(value = "metadata", nulls = Nulls.SKIP, contentNulls = Nulls.AS_EMPTY) + public Builder metadata(@Nonnull Map>> metadata) { + checkNotBuilt(); + this.metadata = new LinkedHashMap<>(Preconditions.checkNotNull(metadata, "metadata cannot be null")); + return this; + } + + public Builder putAllMetadata(@Nonnull Map>> metadata) { + checkNotBuilt(); + this.metadata.putAll(Preconditions.checkNotNull(metadata, "metadata cannot be null")); + return this; + } + + public Builder metadata(StringAliasEx key, Optional> value) { + checkNotBuilt(); + this.metadata.put(key, value); + return this; + } + + @JsonSetter("status") + public Builder status(@Nonnull EnumExample status) { + checkNotBuilt(); + this.status = Preconditions.checkNotNull(status, "status cannot be null"); + return this; + } + + @JsonSetter(value = "variants", nulls = Nulls.SKIP) + public Builder variants(@Nonnull Iterable variants) { + checkNotBuilt(); + this.variants = ConjureCollections.newList(Preconditions.checkNotNull(variants, "variants cannot be null")); + return this; + } + + public Builder addAllVariants(@Nonnull Iterable variants) { + checkNotBuilt(); + ConjureCollections.addAll(this.variants, Preconditions.checkNotNull(variants, "variants cannot be null")); + return this; + } + + public Builder variants(UnionExample variants) { + checkNotBuilt(); + this.variants.add(variants); + return this; + } + + @JsonSetter(value = "external", nulls = Nulls.SKIP) + public Builder external(@Nonnull Optional external) { + checkNotBuilt(); + this.external = Preconditions.checkNotNull(external, "external cannot be null") + .map(Function.identity()); + return this; + } + + public Builder external(long external) { + checkNotBuilt(); + this.external = Optional.of(Preconditions.checkNotNull(external, "external cannot be null")); + return this; + } + + @CheckReturnValue + public ComplexExample build() { + checkNotBuilt(); + this._buildInvoked = true; + return new ComplexExample(metadata, status, variants, external); + } + + private void checkNotBuilt() { + Preconditions.checkState(!_buildInvoked, "Build has already been called"); + } + } +} diff --git a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/EmptyObject.java b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/EmptyObject.java new file mode 100644 index 000000000..2aa865a01 --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/EmptyObject.java @@ -0,0 +1,28 @@ +package jersey.com.palantir.product; + +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.palantir.logsafe.Safe; +import javax.annotation.processing.Generated; + +@Safe +@JsonSerialize +@JsonIgnoreProperties(ignoreUnknown = true) +@Generated("com.palantir.conjure.java.types.BeanGenerator") +public final class EmptyObject { + private static final EmptyObject INSTANCE = new EmptyObject(); + + private EmptyObject() {} + + @Override + @Safe + public String toString() { + return "EmptyObject{}"; + } + + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + public static EmptyObject of() { + return INSTANCE; + } +} diff --git a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/EmptyUnion.java b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/EmptyUnion.java new file mode 100644 index 000000000..128be48b7 --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/EmptyUnion.java @@ -0,0 +1,186 @@ +package jersey.com.palantir.product; + +import com.fasterxml.jackson.annotation.JsonAnyGetter; +import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonTypeInfo; +import com.fasterxml.jackson.annotation.JsonValue; +import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.Safe; +import com.palantir.logsafe.SafeArg; +import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; +import java.util.function.Function; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import javax.annotation.processing.Generated; + +@Generated("com.palantir.conjure.java.types.UnionGenerator") +public final class EmptyUnion { + private final Base value; + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + private EmptyUnion(Base value) { + this.value = value; + } + + @JsonValue + private Base getValue() { + return value; + } + + public static EmptyUnion unknown(@Safe String type, Object value) { + switch (Preconditions.checkNotNull(type, "Type is required")) { + default: + return new EmptyUnion(new UnknownWrapper(type, Collections.singletonMap(type, value))); + } + } + + public T accept(Visitor visitor) { + return value.accept(visitor); + } + + @Override + public boolean equals(@Nullable Object other) { + return this == other || (other instanceof EmptyUnion && equalTo((EmptyUnion) other)); + } + + private boolean equalTo(EmptyUnion other) { + return this.value.equals(other.value); + } + + @Override + public int hashCode() { + return this.value.hashCode(); + } + + @Override + public String toString() { + return "EmptyUnion{value: " + value + '}'; + } + + public interface Visitor { + T visitUnknown(@Safe String unknownType); + + static UnknownStageVisitorBuilder builder() { + return new VisitorBuilder(); + } + } + + private static final class VisitorBuilder + implements UnknownStageVisitorBuilder, Completed_StageVisitorBuilder { + private Function unknownVisitor; + + @Override + public Completed_StageVisitorBuilder unknown(@Nonnull Function unknownVisitor) { + Preconditions.checkNotNull(unknownVisitor, "unknownVisitor cannot be null"); + this.unknownVisitor = unknownVisitor; + return this; + } + + @Override + public Completed_StageVisitorBuilder throwOnUnknown() { + this.unknownVisitor = unknownType -> { + throw new SafeIllegalArgumentException( + "Unknown variant of the 'EmptyUnion' union", SafeArg.of("unknownType", unknownType)); + }; + return this; + } + + @Override + public Visitor build() { + final Function unknownVisitor = this.unknownVisitor; + return new Visitor() { + @Override + public T visitUnknown(String value) { + return unknownVisitor.apply(value); + } + }; + } + } + + public interface UnknownStageVisitorBuilder { + Completed_StageVisitorBuilder unknown(@Nonnull Function unknownVisitor); + + Completed_StageVisitorBuilder throwOnUnknown(); + } + + public interface Completed_StageVisitorBuilder { + Visitor build(); + } + + @JsonTypeInfo( + use = JsonTypeInfo.Id.NAME, + include = JsonTypeInfo.As.EXISTING_PROPERTY, + property = "type", + visible = true, + defaultImpl = UnknownWrapper.class) + @JsonIgnoreProperties(ignoreUnknown = true) + private interface Base { + T accept(Visitor visitor); + } + + private static final class UnknownWrapper implements Base { + private final String type; + + private final Map value; + + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + private UnknownWrapper(@JsonProperty("type") String type) { + this(type, new HashMap()); + } + + private UnknownWrapper(@Nonnull String type, @Nonnull Map value) { + Preconditions.checkNotNull(type, "type cannot be null"); + Preconditions.checkNotNull(value, "value cannot be null"); + this.type = type; + this.value = value; + } + + @JsonProperty + private String getType() { + return type; + } + + @JsonAnyGetter + private Map getValue() { + return value; + } + + @JsonAnySetter + private void put(String key, Object val) { + value.put(key, val); + } + + @Override + public T accept(Visitor visitor) { + return visitor.visitUnknown(type); + } + + @Override + public boolean equals(@Nullable Object other) { + return this == other || (other instanceof UnknownWrapper && equalTo((UnknownWrapper) other)); + } + + private boolean equalTo(UnknownWrapper other) { + return this.type.equals(other.type) && this.value.equals(other.value); + } + + @Override + public int hashCode() { + int hash = 1; + hash = 31 * hash + this.type.hashCode(); + hash = 31 * hash + this.value.hashCode(); + return hash; + } + + @Override + public String toString() { + return "UnknownWrapper{type: " + type + ", value: " + value + '}'; + } + } +} diff --git a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/EnumExample.java b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/EnumExample.java new file mode 100644 index 000000000..6b6cacfc3 --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/EnumExample.java @@ -0,0 +1,205 @@ +package jersey.com.palantir.product; + +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonValue; +import com.google.errorprone.annotations.Immutable; +import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.Safe; +import com.palantir.logsafe.SafeArg; +import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.Locale; +import java.util.function.Function; +import java.util.function.Supplier; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import javax.annotation.processing.Generated; + +/** + * This class is used instead of a native enum to support unknown values. Rather than throw an exception, the + * {@link EnumExample#valueOf} method defaults to a new instantiation of {@link EnumExample} where + * {@link EnumExample#get} will return {@link EnumExample.Value#UNKNOWN}. + * + *

For example, {@code EnumExample.valueOf("corrupted value").get()} will return {@link EnumExample.Value#UNKNOWN}, + * but {@link EnumExample#toString} will return "corrupted value". + * + *

There is no method to access all instantiations of this class, since they cannot be known at compile time. + */ +@Generated("com.palantir.conjure.java.types.EnumGenerator") +@Safe +@Immutable +public final class EnumExample { + public static final EnumExample A = new EnumExample(Value.A, "A"); + + public static final EnumExample B = new EnumExample(Value.B, "B"); + + private static final List values = Collections.unmodifiableList(Arrays.asList(A, B)); + + private final Value value; + + private final String string; + + private EnumExample(Value value, String string) { + this.value = value; + this.string = string; + } + + public Value get() { + return this.value; + } + + @Override + @JsonValue + public String toString() { + return this.string; + } + + @Override + public boolean equals(@Nullable Object other) { + return (this == other) + || (this.value == Value.UNKNOWN + && other instanceof EnumExample + && this.string.equals(((EnumExample) other).string)); + } + + @Override + public int hashCode() { + return this.string.hashCode(); + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static EnumExample valueOf(@Nonnull @Safe String value) { + Preconditions.checkNotNull(value, "value cannot be null"); + String upperCasedValue = value.toUpperCase(Locale.ROOT); + switch (upperCasedValue) { + case "A": + return A; + case "B": + return B; + default: + return new EnumExample(Value.UNKNOWN, upperCasedValue); + } + } + + public T accept(Visitor visitor) { + switch (value) { + case A: + return visitor.visitA(); + case B: + return visitor.visitB(); + default: + return visitor.visitUnknown(string); + } + } + + public static List values() { + return values; + } + + @Generated("com.palantir.conjure.java.types.EnumGenerator") + public enum Value { + A, + + B, + + UNKNOWN + } + + @Generated("com.palantir.conjure.java.types.EnumGenerator") + public interface Visitor { + T visitA(); + + T visitB(); + + T visitUnknown(String unknownValue); + + static AStageVisitorBuilder builder() { + return new VisitorBuilder(); + } + } + + private static final class VisitorBuilder + implements AStageVisitorBuilder, + BStageVisitorBuilder, + UnknownStageVisitorBuilder, + Completed_StageVisitorBuilder { + private Supplier aVisitor; + + private Supplier bVisitor; + + private Function<@Safe String, T> unknownVisitor; + + @Override + public BStageVisitorBuilder visitA(@Nonnull Supplier aVisitor) { + Preconditions.checkNotNull(aVisitor, "aVisitor cannot be null"); + this.aVisitor = aVisitor; + return this; + } + + @Override + public UnknownStageVisitorBuilder visitB(@Nonnull Supplier bVisitor) { + Preconditions.checkNotNull(bVisitor, "bVisitor cannot be null"); + this.bVisitor = bVisitor; + return this; + } + + @Override + public Completed_StageVisitorBuilder visitUnknown(@Nonnull Function<@Safe String, T> unknownVisitor) { + Preconditions.checkNotNull(unknownVisitor, "unknownVisitor cannot be null"); + this.unknownVisitor = unknownType -> unknownVisitor.apply(unknownType); + return this; + } + + @Override + public Completed_StageVisitorBuilder throwOnUnknown() { + this.unknownVisitor = unknownType -> { + throw new SafeIllegalArgumentException( + "Unknown variant of the 'EnumExample' union", SafeArg.of("unknownType", unknownType)); + }; + return this; + } + + @Override + public Visitor build() { + final Supplier aVisitor = this.aVisitor; + final Supplier bVisitor = this.bVisitor; + final Function<@Safe String, T> unknownVisitor = this.unknownVisitor; + return new Visitor() { + @Override + public T visitA() { + return aVisitor.get(); + } + + @Override + public T visitB() { + return bVisitor.get(); + } + + @Override + public T visitUnknown(String unknownType) { + return unknownVisitor.apply(unknownType); + } + }; + } + } + + public interface AStageVisitorBuilder { + BStageVisitorBuilder visitA(@Nonnull Supplier aVisitor); + } + + public interface BStageVisitorBuilder { + UnknownStageVisitorBuilder visitB(@Nonnull Supplier bVisitor); + } + + public interface UnknownStageVisitorBuilder { + Completed_StageVisitorBuilder visitUnknown(@Nonnull Function<@Safe String, T> unknownVisitor); + + Completed_StageVisitorBuilder throwOnUnknown(); + } + + public interface Completed_StageVisitorBuilder { + Visitor build(); + } +} diff --git a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/ExternalExample.java b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/ExternalExample.java new file mode 100644 index 000000000..4b45e6790 --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/ExternalExample.java @@ -0,0 +1,183 @@ +package jersey.com.palantir.product; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonSetter; +import com.fasterxml.jackson.annotation.Nulls; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import com.google.errorprone.annotations.CheckReturnValue; +import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.SafeArg; +import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; +import java.util.function.Function; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import javax.annotation.processing.Generated; + +@JsonDeserialize(builder = ExternalExample.Builder.class) +@Generated("com.palantir.conjure.java.types.BeanGenerator") +public final class ExternalExample { + private final long externalLong; + + private final Optional optionalExternal; + + private int memoizedHashCode; + + private ExternalExample(long externalLong, Optional optionalExternal) { + validateFields(optionalExternal); + this.externalLong = externalLong; + this.optionalExternal = optionalExternal; + } + + @JsonProperty("externalLong") + public long getExternalLong() { + return this.externalLong; + } + + @JsonProperty("optionalExternal") + public Optional getOptionalExternal() { + return this.optionalExternal; + } + + @Override + public boolean equals(@Nullable Object other) { + return this == other || (other instanceof ExternalExample && equalTo((ExternalExample) other)); + } + + private boolean equalTo(ExternalExample other) { + if (this.memoizedHashCode != 0 + && other.memoizedHashCode != 0 + && this.memoizedHashCode != other.memoizedHashCode) { + return false; + } + return this.externalLong == other.externalLong && this.optionalExternal.equals(other.optionalExternal); + } + + @Override + public int hashCode() { + int result = memoizedHashCode; + if (result == 0) { + int hash = 1; + hash = 31 * hash + Long.hashCode(this.externalLong); + hash = 31 * hash + this.optionalExternal.hashCode(); + result = hash; + memoizedHashCode = result; + } + return result; + } + + @Override + public String toString() { + return "ExternalExample{externalLong: " + externalLong + ", optionalExternal: " + optionalExternal + '}'; + } + + public static ExternalExample of(long externalLong, long optionalExternal) { + return builder() + .externalLong(externalLong) + .optionalExternal(Optional.of(optionalExternal)) + .build(); + } + + private static void validateFields(Optional optionalExternal) { + List missingFields = null; + missingFields = addFieldIfMissing(missingFields, optionalExternal, "optionalExternal"); + if (missingFields != null) { + throw new SafeIllegalArgumentException( + "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); + } + } + + private static List addFieldIfMissing(List prev, Object fieldValue, String fieldName) { + List missingFields = prev; + if (fieldValue == null) { + if (missingFields == null) { + missingFields = new ArrayList<>(1); + } + missingFields.add(fieldName); + } + return missingFields; + } + + public static Builder builder() { + return new Builder(); + } + + @Generated("com.palantir.conjure.java.types.BeanBuilderGenerator") + @JsonIgnoreProperties(ignoreUnknown = true) + public static final class Builder { + boolean _buildInvoked; + + private long externalLong; + + private Optional optionalExternal = Optional.empty(); + + private boolean _externalLongInitialized = false; + + private Builder() {} + + public Builder from(ExternalExample other) { + checkNotBuilt(); + externalLong(other.getExternalLong()); + optionalExternal(other.getOptionalExternal()); + return this; + } + + @JsonSetter("externalLong") + public Builder externalLong(long externalLong) { + checkNotBuilt(); + this.externalLong = externalLong; + this._externalLongInitialized = true; + return this; + } + + @JsonSetter(value = "optionalExternal", nulls = Nulls.SKIP) + public Builder optionalExternal(@Nonnull Optional optionalExternal) { + checkNotBuilt(); + this.optionalExternal = Preconditions.checkNotNull(optionalExternal, "optionalExternal cannot be null") + .map(Function.identity()); + return this; + } + + public Builder optionalExternal(long optionalExternal) { + checkNotBuilt(); + this.optionalExternal = + Optional.of(Preconditions.checkNotNull(optionalExternal, "optionalExternal cannot be null")); + return this; + } + + private void validatePrimitiveFieldsHaveBeenInitialized() { + List missingFields = null; + missingFields = addFieldIfMissing(missingFields, _externalLongInitialized, "externalLong"); + if (missingFields != null) { + throw new SafeIllegalArgumentException( + "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); + } + } + + private static List addFieldIfMissing(List prev, boolean initialized, String fieldName) { + List missingFields = prev; + if (!initialized) { + if (missingFields == null) { + missingFields = new ArrayList<>(1); + } + missingFields.add(fieldName); + } + return missingFields; + } + + @CheckReturnValue + public ExternalExample build() { + checkNotBuilt(); + this._buildInvoked = true; + validatePrimitiveFieldsHaveBeenInitialized(); + return new ExternalExample(externalLong, optionalExternal); + } + + private void checkNotBuilt() { + Preconditions.checkState(!_buildInvoked, "Build has already been called"); + } + } +} diff --git a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/NestedAlias.java b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/NestedAlias.java new file mode 100644 index 000000000..04024beb9 --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/NestedAlias.java @@ -0,0 +1,52 @@ +package jersey.com.palantir.product; + +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonValue; +import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.Safe; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import javax.annotation.processing.Generated; + +@Safe +@Generated("com.palantir.conjure.java.types.AliasGenerator") +public final class NestedAlias { + private final StringAliasEx value; + + private NestedAlias(@Nonnull StringAliasEx value) { + this.value = Preconditions.checkNotNull(value, "value cannot be null"); + } + + @JsonValue + public StringAliasEx get() { + return value; + } + + @Override + public String toString() { + return value.toString(); + } + + @Override + public boolean equals(@Nullable Object other) { + return this == other || (other instanceof NestedAlias && equalTo((NestedAlias) other)); + } + + private boolean equalTo(NestedAlias other) { + return this.value.equals(other.value); + } + + @Override + public int hashCode() { + return this.value.hashCode(); + } + + public static NestedAlias valueOf(@Safe String value) { + return of(StringAliasEx.valueOf(value)); + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static NestedAlias of(@Nonnull StringAliasEx value) { + return new NestedAlias(value); + } +} diff --git a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/NestedCollectionExample.java b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/NestedCollectionExample.java new file mode 100644 index 000000000..9e64285c5 --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/NestedCollectionExample.java @@ -0,0 +1,226 @@ +package jersey.com.palantir.product; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonSetter; +import com.fasterxml.jackson.annotation.Nulls; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import com.google.errorprone.annotations.CheckReturnValue; +import com.palantir.conjure.java.lib.internal.ConjureCollections; +import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.SafeArg; +import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; +import java.util.ArrayList; +import java.util.Collections; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import javax.annotation.processing.Generated; + +@JsonDeserialize(builder = NestedCollectionExample.Builder.class) +@Generated("com.palantir.conjure.java.types.BeanGenerator") +public final class NestedCollectionExample { + private final List> nestedList; + + private final Map> nestedMap; + + private final Map> mixedCollection; + + private int memoizedHashCode; + + private NestedCollectionExample( + List> nestedList, + Map> nestedMap, + Map> mixedCollection) { + validateFields(nestedList, nestedMap, mixedCollection); + this.nestedList = ConjureCollections.unmodifiableList(nestedList); + this.nestedMap = Collections.unmodifiableMap(nestedMap); + this.mixedCollection = Collections.unmodifiableMap(mixedCollection); + } + + @JsonProperty("nestedList") + public List> getNestedList() { + return this.nestedList; + } + + @JsonProperty("nestedMap") + public Map> getNestedMap() { + return this.nestedMap; + } + + @JsonProperty("mixedCollection") + public Map> getMixedCollection() { + return this.mixedCollection; + } + + @Override + public boolean equals(@Nullable Object other) { + return this == other || (other instanceof NestedCollectionExample && equalTo((NestedCollectionExample) other)); + } + + private boolean equalTo(NestedCollectionExample other) { + if (this.memoizedHashCode != 0 + && other.memoizedHashCode != 0 + && this.memoizedHashCode != other.memoizedHashCode) { + return false; + } + return this.nestedList.equals(other.nestedList) + && this.nestedMap.equals(other.nestedMap) + && this.mixedCollection.equals(other.mixedCollection); + } + + @Override + public int hashCode() { + int result = memoizedHashCode; + if (result == 0) { + int hash = 1; + hash = 31 * hash + this.nestedList.hashCode(); + hash = 31 * hash + this.nestedMap.hashCode(); + hash = 31 * hash + this.mixedCollection.hashCode(); + result = hash; + memoizedHashCode = result; + } + return result; + } + + @Override + public String toString() { + return "NestedCollectionExample{nestedList: " + nestedList + ", nestedMap: " + nestedMap + ", mixedCollection: " + + mixedCollection + '}'; + } + + public static NestedCollectionExample of( + List> nestedList, + Map> nestedMap, + Map> mixedCollection) { + return builder() + .nestedList(nestedList) + .nestedMap(nestedMap) + .mixedCollection(mixedCollection) + .build(); + } + + private static void validateFields( + List> nestedList, + Map> nestedMap, + Map> mixedCollection) { + List missingFields = null; + missingFields = addFieldIfMissing(missingFields, nestedList, "nestedList"); + missingFields = addFieldIfMissing(missingFields, nestedMap, "nestedMap"); + missingFields = addFieldIfMissing(missingFields, mixedCollection, "mixedCollection"); + if (missingFields != null) { + throw new SafeIllegalArgumentException( + "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); + } + } + + private static List addFieldIfMissing(List prev, Object fieldValue, String fieldName) { + List missingFields = prev; + if (fieldValue == null) { + if (missingFields == null) { + missingFields = new ArrayList<>(3); + } + missingFields.add(fieldName); + } + return missingFields; + } + + public static Builder builder() { + return new Builder(); + } + + @Generated("com.palantir.conjure.java.types.BeanBuilderGenerator") + @JsonIgnoreProperties(ignoreUnknown = true) + public static final class Builder { + boolean _buildInvoked; + + private List> nestedList = ConjureCollections.newList(); + + private Map> nestedMap = new LinkedHashMap<>(); + + private Map> mixedCollection = new LinkedHashMap<>(); + + private Builder() {} + + public Builder from(NestedCollectionExample other) { + checkNotBuilt(); + nestedList(other.getNestedList()); + nestedMap(other.getNestedMap()); + mixedCollection(other.getMixedCollection()); + return this; + } + + @JsonSetter(value = "nestedList", nulls = Nulls.SKIP) + public Builder nestedList(@Nonnull Iterable> nestedList) { + checkNotBuilt(); + this.nestedList = + ConjureCollections.newList(Preconditions.checkNotNull(nestedList, "nestedList cannot be null")); + return this; + } + + public Builder addAllNestedList(@Nonnull Iterable> nestedList) { + checkNotBuilt(); + ConjureCollections.addAll( + this.nestedList, Preconditions.checkNotNull(nestedList, "nestedList cannot be null")); + return this; + } + + public Builder nestedList(List nestedList) { + checkNotBuilt(); + this.nestedList.add(nestedList); + return this; + } + + @JsonSetter(value = "nestedMap", nulls = Nulls.SKIP) + public Builder nestedMap(@Nonnull Map> nestedMap) { + checkNotBuilt(); + this.nestedMap = new LinkedHashMap<>(Preconditions.checkNotNull(nestedMap, "nestedMap cannot be null")); + return this; + } + + public Builder putAllNestedMap(@Nonnull Map> nestedMap) { + checkNotBuilt(); + this.nestedMap.putAll(Preconditions.checkNotNull(nestedMap, "nestedMap cannot be null")); + return this; + } + + public Builder nestedMap(String key, Map value) { + checkNotBuilt(); + this.nestedMap.put(key, value); + return this; + } + + @JsonSetter(value = "mixedCollection", nulls = Nulls.SKIP) + public Builder mixedCollection(@Nonnull Map> mixedCollection) { + checkNotBuilt(); + this.mixedCollection = + new LinkedHashMap<>(Preconditions.checkNotNull(mixedCollection, "mixedCollection cannot be null")); + return this; + } + + public Builder putAllMixedCollection(@Nonnull Map> mixedCollection) { + checkNotBuilt(); + this.mixedCollection.putAll(Preconditions.checkNotNull(mixedCollection, "mixedCollection cannot be null")); + return this; + } + + public Builder mixedCollection(String key, List value) { + checkNotBuilt(); + this.mixedCollection.put(key, value); + return this; + } + + @CheckReturnValue + public NestedCollectionExample build() { + checkNotBuilt(); + this._buildInvoked = true; + return new NestedCollectionExample(nestedList, nestedMap, mixedCollection); + } + + private void checkNotBuilt() { + Preconditions.checkState(!_buildInvoked, "Build has already been called"); + } + } +} diff --git a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/ObjectReference.java b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/ObjectReference.java new file mode 100644 index 000000000..4d0b4b9d0 --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/ObjectReference.java @@ -0,0 +1,169 @@ +package jersey.com.palantir.product; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonSetter; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import com.google.errorprone.annotations.CheckReturnValue; +import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.SafeArg; +import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; +import java.util.ArrayList; +import java.util.List; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import javax.annotation.processing.Generated; + +@JsonDeserialize(builder = ObjectReference.Builder.class) +@Generated("com.palantir.conjure.java.types.BeanGenerator") +public final class ObjectReference { + private final String name; + + private final int value; + + private int memoizedHashCode; + + private ObjectReference(String name, int value) { + validateFields(name); + this.name = name; + this.value = value; + } + + @JsonProperty("name") + public String getName() { + return this.name; + } + + @JsonProperty("value") + public int getValue() { + return this.value; + } + + @Override + public boolean equals(@Nullable Object other) { + return this == other || (other instanceof ObjectReference && equalTo((ObjectReference) other)); + } + + private boolean equalTo(ObjectReference other) { + if (this.memoizedHashCode != 0 + && other.memoizedHashCode != 0 + && this.memoizedHashCode != other.memoizedHashCode) { + return false; + } + return this.name.equals(other.name) && this.value == other.value; + } + + @Override + public int hashCode() { + int result = memoizedHashCode; + if (result == 0) { + int hash = 1; + hash = 31 * hash + this.name.hashCode(); + hash = 31 * hash + this.value; + result = hash; + memoizedHashCode = result; + } + return result; + } + + @Override + public String toString() { + return "ObjectReference{name: " + name + ", value: " + value + '}'; + } + + public static ObjectReference of(String name, int value) { + return builder().name(name).value(value).build(); + } + + private static void validateFields(String name) { + List missingFields = null; + missingFields = addFieldIfMissing(missingFields, name, "name"); + if (missingFields != null) { + throw new SafeIllegalArgumentException( + "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); + } + } + + private static List addFieldIfMissing(List prev, Object fieldValue, String fieldName) { + List missingFields = prev; + if (fieldValue == null) { + if (missingFields == null) { + missingFields = new ArrayList<>(1); + } + missingFields.add(fieldName); + } + return missingFields; + } + + public static Builder builder() { + return new Builder(); + } + + @Generated("com.palantir.conjure.java.types.BeanBuilderGenerator") + @JsonIgnoreProperties(ignoreUnknown = true) + public static final class Builder { + boolean _buildInvoked; + + private String name; + + private int value; + + private boolean _valueInitialized = false; + + private Builder() {} + + public Builder from(ObjectReference other) { + checkNotBuilt(); + name(other.getName()); + value(other.getValue()); + return this; + } + + @JsonSetter("name") + public Builder name(@Nonnull String name) { + checkNotBuilt(); + this.name = Preconditions.checkNotNull(name, "name cannot be null"); + return this; + } + + @JsonSetter("value") + public Builder value(int value) { + checkNotBuilt(); + this.value = value; + this._valueInitialized = true; + return this; + } + + private void validatePrimitiveFieldsHaveBeenInitialized() { + List missingFields = null; + missingFields = addFieldIfMissing(missingFields, _valueInitialized, "value"); + if (missingFields != null) { + throw new SafeIllegalArgumentException( + "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); + } + } + + private static List addFieldIfMissing(List prev, boolean initialized, String fieldName) { + List missingFields = prev; + if (!initialized) { + if (missingFields == null) { + missingFields = new ArrayList<>(1); + } + missingFields.add(fieldName); + } + return missingFields; + } + + @CheckReturnValue + public ObjectReference build() { + checkNotBuilt(); + this._buildInvoked = true; + validatePrimitiveFieldsHaveBeenInitialized(); + return new ObjectReference(name, value); + } + + private void checkNotBuilt() { + Preconditions.checkState(!_buildInvoked, "Build has already been called"); + } + } +} diff --git a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/OptionalAlias.java b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/OptionalAlias.java new file mode 100644 index 000000000..e0a954b10 --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/OptionalAlias.java @@ -0,0 +1,60 @@ +package jersey.com.palantir.product; + +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonValue; +import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.Safe; +import java.util.Optional; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import javax.annotation.processing.Generated; + +@Safe +@Generated("com.palantir.conjure.java.types.AliasGenerator") +public final class OptionalAlias { + private static final OptionalAlias EMPTY = new OptionalAlias(); + + private final Optional<@Safe String> value; + + private OptionalAlias(@Nonnull Optional<@Safe String> value) { + this.value = Preconditions.checkNotNull(value, "value cannot be null"); + } + + private OptionalAlias() { + this(Optional.empty()); + } + + @JsonValue + public Optional<@Safe String> get() { + return value; + } + + @Override + @Safe + public String toString() { + return value.toString(); + } + + @Override + public boolean equals(@Nullable Object other) { + return this == other || (other instanceof OptionalAlias && equalTo((OptionalAlias) other)); + } + + private boolean equalTo(OptionalAlias other) { + return this.value.equals(other.value); + } + + @Override + public int hashCode() { + return this.value.hashCode(); + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static OptionalAlias of(@Nonnull Optional<@Safe String> value) { + return new OptionalAlias(value); + } + + public static OptionalAlias empty() { + return EMPTY; + } +} diff --git a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/OptionalExample.java b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/OptionalExample.java new file mode 100644 index 000000000..855c1d847 --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/OptionalExample.java @@ -0,0 +1,206 @@ +package jersey.com.palantir.product; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonSetter; +import com.fasterxml.jackson.annotation.Nulls; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import com.google.errorprone.annotations.CheckReturnValue; +import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.SafeArg; +import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; +import java.util.function.Function; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import javax.annotation.processing.Generated; + +@JsonDeserialize(builder = OptionalExample.Builder.class) +@Generated("com.palantir.conjure.java.types.BeanGenerator") +public final class OptionalExample { + private final Optional optionalString; + + private final Optional optionalObject; + + private final Optional> optionalCollection; + + private int memoizedHashCode; + + private OptionalExample( + Optional optionalString, + Optional optionalObject, + Optional> optionalCollection) { + validateFields(optionalString, optionalObject, optionalCollection); + this.optionalString = optionalString; + this.optionalObject = optionalObject; + this.optionalCollection = optionalCollection; + } + + @JsonProperty("optionalString") + public Optional getOptionalString() { + return this.optionalString; + } + + @JsonProperty("optionalObject") + public Optional getOptionalObject() { + return this.optionalObject; + } + + @JsonProperty("optionalCollection") + public Optional> getOptionalCollection() { + return this.optionalCollection; + } + + @Override + public boolean equals(@Nullable Object other) { + return this == other || (other instanceof OptionalExample && equalTo((OptionalExample) other)); + } + + private boolean equalTo(OptionalExample other) { + if (this.memoizedHashCode != 0 + && other.memoizedHashCode != 0 + && this.memoizedHashCode != other.memoizedHashCode) { + return false; + } + return this.optionalString.equals(other.optionalString) + && this.optionalObject.equals(other.optionalObject) + && this.optionalCollection.equals(other.optionalCollection); + } + + @Override + public int hashCode() { + int result = memoizedHashCode; + if (result == 0) { + int hash = 1; + hash = 31 * hash + this.optionalString.hashCode(); + hash = 31 * hash + this.optionalObject.hashCode(); + hash = 31 * hash + this.optionalCollection.hashCode(); + result = hash; + memoizedHashCode = result; + } + return result; + } + + @Override + public String toString() { + return "OptionalExample{optionalString: " + optionalString + ", optionalObject: " + optionalObject + + ", optionalCollection: " + optionalCollection + '}'; + } + + public static OptionalExample of( + String optionalString, ObjectReference optionalObject, List optionalCollection) { + return builder() + .optionalString(Optional.of(optionalString)) + .optionalObject(Optional.of(optionalObject)) + .optionalCollection(Optional.of(optionalCollection)) + .build(); + } + + private static void validateFields( + Optional optionalString, + Optional optionalObject, + Optional> optionalCollection) { + List missingFields = null; + missingFields = addFieldIfMissing(missingFields, optionalString, "optionalString"); + missingFields = addFieldIfMissing(missingFields, optionalObject, "optionalObject"); + missingFields = addFieldIfMissing(missingFields, optionalCollection, "optionalCollection"); + if (missingFields != null) { + throw new SafeIllegalArgumentException( + "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); + } + } + + private static List addFieldIfMissing(List prev, Object fieldValue, String fieldName) { + List missingFields = prev; + if (fieldValue == null) { + if (missingFields == null) { + missingFields = new ArrayList<>(3); + } + missingFields.add(fieldName); + } + return missingFields; + } + + public static Builder builder() { + return new Builder(); + } + + @Generated("com.palantir.conjure.java.types.BeanBuilderGenerator") + @JsonIgnoreProperties(ignoreUnknown = true) + public static final class Builder { + boolean _buildInvoked; + + private Optional optionalString = Optional.empty(); + + private Optional optionalObject = Optional.empty(); + + private Optional> optionalCollection = Optional.empty(); + + private Builder() {} + + public Builder from(OptionalExample other) { + checkNotBuilt(); + optionalString(other.getOptionalString()); + optionalObject(other.getOptionalObject()); + optionalCollection(other.getOptionalCollection()); + return this; + } + + @JsonSetter(value = "optionalString", nulls = Nulls.SKIP) + public Builder optionalString(@Nonnull Optional optionalString) { + checkNotBuilt(); + this.optionalString = Preconditions.checkNotNull(optionalString, "optionalString cannot be null"); + return this; + } + + public Builder optionalString(@Nonnull String optionalString) { + checkNotBuilt(); + this.optionalString = + Optional.of(Preconditions.checkNotNull(optionalString, "optionalString cannot be null")); + return this; + } + + @JsonSetter(value = "optionalObject", nulls = Nulls.SKIP) + public Builder optionalObject(@Nonnull Optional optionalObject) { + checkNotBuilt(); + this.optionalObject = Preconditions.checkNotNull(optionalObject, "optionalObject cannot be null"); + return this; + } + + public Builder optionalObject(@Nonnull ObjectReference optionalObject) { + checkNotBuilt(); + this.optionalObject = + Optional.of(Preconditions.checkNotNull(optionalObject, "optionalObject cannot be null")); + return this; + } + + @JsonSetter(value = "optionalCollection", nulls = Nulls.SKIP) + public Builder optionalCollection(@Nonnull Optional> optionalCollection) { + checkNotBuilt(); + this.optionalCollection = Preconditions.checkNotNull( + optionalCollection, "optionalCollection cannot be null") + .map(Function.identity()); + return this; + } + + public Builder optionalCollection(@Nonnull List optionalCollection) { + checkNotBuilt(); + this.optionalCollection = + Optional.of(Preconditions.checkNotNull(optionalCollection, "optionalCollection cannot be null")); + return this; + } + + @CheckReturnValue + public OptionalExample build() { + checkNotBuilt(); + this._buildInvoked = true; + return new OptionalExample(optionalString, optionalObject, optionalCollection); + } + + private void checkNotBuilt() { + Preconditions.checkState(!_buildInvoked, "Build has already been called"); + } + } +} diff --git a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/PrimitiveExample.java b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/PrimitiveExample.java new file mode 100644 index 000000000..000257feb --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/PrimitiveExample.java @@ -0,0 +1,345 @@ +package jersey.com.palantir.product; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonSetter; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import com.google.errorprone.annotations.CheckReturnValue; +import com.palantir.conjure.java.lib.SafeLong; +import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.SafeArg; +import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; +import com.palantir.ri.ResourceIdentifier; +import java.nio.Buffer; +import java.nio.ByteBuffer; +import java.time.OffsetDateTime; +import java.util.ArrayList; +import java.util.List; +import java.util.UUID; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import javax.annotation.processing.Generated; + +@JsonDeserialize(builder = PrimitiveExample.Builder.class) +@Generated("com.palantir.conjure.java.types.BeanGenerator") +public final class PrimitiveExample { + private final String stringVal; + + private final int intVal; + + private final SafeLong longVal; + + private final double doubleVal; + + private final boolean boolVal; + + private final ResourceIdentifier ridVal; + + private final UUID uuidVal; + + private final OffsetDateTime datetimeVal; + + private final ByteBuffer binaryVal; + + private int memoizedHashCode; + + private PrimitiveExample( + String stringVal, + int intVal, + SafeLong longVal, + double doubleVal, + boolean boolVal, + ResourceIdentifier ridVal, + UUID uuidVal, + OffsetDateTime datetimeVal, + ByteBuffer binaryVal) { + validateFields(stringVal, longVal, ridVal, uuidVal, datetimeVal, binaryVal); + this.stringVal = stringVal; + this.intVal = intVal; + this.longVal = longVal; + this.doubleVal = doubleVal; + this.boolVal = boolVal; + this.ridVal = ridVal; + this.uuidVal = uuidVal; + this.datetimeVal = datetimeVal; + this.binaryVal = binaryVal; + } + + @JsonProperty("stringVal") + public String getStringVal() { + return this.stringVal; + } + + @JsonProperty("intVal") + public int getIntVal() { + return this.intVal; + } + + @JsonProperty("longVal") + public SafeLong getLongVal() { + return this.longVal; + } + + @JsonProperty("doubleVal") + public double getDoubleVal() { + return this.doubleVal; + } + + @JsonProperty("boolVal") + public boolean getBoolVal() { + return this.boolVal; + } + + @JsonProperty("ridVal") + public ResourceIdentifier getRidVal() { + return this.ridVal; + } + + @JsonProperty("uuidVal") + public UUID getUuidVal() { + return this.uuidVal; + } + + @JsonProperty("datetimeVal") + public OffsetDateTime getDatetimeVal() { + return this.datetimeVal; + } + + @JsonProperty("binaryVal") + public ByteBuffer getBinaryVal() { + return this.binaryVal.asReadOnlyBuffer(); + } + + @Override + public boolean equals(@Nullable Object other) { + return this == other || (other instanceof PrimitiveExample && equalTo((PrimitiveExample) other)); + } + + private boolean equalTo(PrimitiveExample other) { + if (this.memoizedHashCode != 0 + && other.memoizedHashCode != 0 + && this.memoizedHashCode != other.memoizedHashCode) { + return false; + } + return this.stringVal.equals(other.stringVal) + && this.intVal == other.intVal + && this.longVal.equals(other.longVal) + && Double.doubleToLongBits(this.doubleVal) == Double.doubleToLongBits(other.doubleVal) + && this.boolVal == other.boolVal + && this.ridVal.equals(other.ridVal) + && this.uuidVal.equals(other.uuidVal) + && this.datetimeVal.isEqual(other.datetimeVal) + && this.binaryVal.equals(other.binaryVal); + } + + @Override + public int hashCode() { + int result = memoizedHashCode; + if (result == 0) { + int hash = 1; + hash = 31 * hash + this.stringVal.hashCode(); + hash = 31 * hash + this.intVal; + hash = 31 * hash + this.longVal.hashCode(); + hash = 31 * hash + Double.hashCode(this.doubleVal); + hash = 31 * hash + Boolean.hashCode(this.boolVal); + hash = 31 * hash + this.ridVal.hashCode(); + hash = 31 * hash + this.uuidVal.hashCode(); + hash = 31 * hash + this.datetimeVal.toInstant().hashCode(); + hash = 31 * hash + this.binaryVal.hashCode(); + result = hash; + memoizedHashCode = result; + } + return result; + } + + @Override + public String toString() { + return "PrimitiveExample{stringVal: " + stringVal + ", intVal: " + intVal + ", longVal: " + longVal + + ", doubleVal: " + doubleVal + ", boolVal: " + boolVal + ", ridVal: " + ridVal + ", uuidVal: " + + uuidVal + ", datetimeVal: " + datetimeVal + ", binaryVal: " + binaryVal + '}'; + } + + private static void validateFields( + String stringVal, + SafeLong longVal, + ResourceIdentifier ridVal, + UUID uuidVal, + OffsetDateTime datetimeVal, + ByteBuffer binaryVal) { + List missingFields = null; + missingFields = addFieldIfMissing(missingFields, stringVal, "stringVal"); + missingFields = addFieldIfMissing(missingFields, longVal, "longVal"); + missingFields = addFieldIfMissing(missingFields, ridVal, "ridVal"); + missingFields = addFieldIfMissing(missingFields, uuidVal, "uuidVal"); + missingFields = addFieldIfMissing(missingFields, datetimeVal, "datetimeVal"); + missingFields = addFieldIfMissing(missingFields, binaryVal, "binaryVal"); + if (missingFields != null) { + throw new SafeIllegalArgumentException( + "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); + } + } + + private static List addFieldIfMissing(List prev, Object fieldValue, String fieldName) { + List missingFields = prev; + if (fieldValue == null) { + if (missingFields == null) { + missingFields = new ArrayList<>(6); + } + missingFields.add(fieldName); + } + return missingFields; + } + + public static Builder builder() { + return new Builder(); + } + + @Generated("com.palantir.conjure.java.types.BeanBuilderGenerator") + @JsonIgnoreProperties(ignoreUnknown = true) + public static final class Builder { + boolean _buildInvoked; + + private String stringVal; + + private int intVal; + + private SafeLong longVal; + + private double doubleVal; + + private boolean boolVal; + + private ResourceIdentifier ridVal; + + private UUID uuidVal; + + private OffsetDateTime datetimeVal; + + private ByteBuffer binaryVal; + + private boolean _intValInitialized = false; + + private boolean _doubleValInitialized = false; + + private boolean _boolValInitialized = false; + + private Builder() {} + + public Builder from(PrimitiveExample other) { + checkNotBuilt(); + stringVal(other.getStringVal()); + intVal(other.getIntVal()); + longVal(other.getLongVal()); + doubleVal(other.getDoubleVal()); + boolVal(other.getBoolVal()); + ridVal(other.getRidVal()); + uuidVal(other.getUuidVal()); + datetimeVal(other.getDatetimeVal()); + binaryVal(other.getBinaryVal()); + return this; + } + + @JsonSetter("stringVal") + public Builder stringVal(@Nonnull String stringVal) { + checkNotBuilt(); + this.stringVal = Preconditions.checkNotNull(stringVal, "stringVal cannot be null"); + return this; + } + + @JsonSetter("intVal") + public Builder intVal(int intVal) { + checkNotBuilt(); + this.intVal = intVal; + this._intValInitialized = true; + return this; + } + + @JsonSetter("longVal") + public Builder longVal(@Nonnull SafeLong longVal) { + checkNotBuilt(); + this.longVal = Preconditions.checkNotNull(longVal, "longVal cannot be null"); + return this; + } + + @JsonSetter("doubleVal") + public Builder doubleVal(double doubleVal) { + checkNotBuilt(); + this.doubleVal = doubleVal; + this._doubleValInitialized = true; + return this; + } + + @JsonSetter("boolVal") + public Builder boolVal(boolean boolVal) { + checkNotBuilt(); + this.boolVal = boolVal; + this._boolValInitialized = true; + return this; + } + + @JsonSetter("ridVal") + public Builder ridVal(@Nonnull ResourceIdentifier ridVal) { + checkNotBuilt(); + this.ridVal = Preconditions.checkNotNull(ridVal, "ridVal cannot be null"); + return this; + } + + @JsonSetter("uuidVal") + public Builder uuidVal(@Nonnull UUID uuidVal) { + checkNotBuilt(); + this.uuidVal = Preconditions.checkNotNull(uuidVal, "uuidVal cannot be null"); + return this; + } + + @JsonSetter("datetimeVal") + public Builder datetimeVal(@Nonnull OffsetDateTime datetimeVal) { + checkNotBuilt(); + this.datetimeVal = Preconditions.checkNotNull(datetimeVal, "datetimeVal cannot be null"); + return this; + } + + @JsonSetter("binaryVal") + public Builder binaryVal(@Nonnull ByteBuffer binaryVal) { + checkNotBuilt(); + Preconditions.checkNotNull(binaryVal, "binaryVal cannot be null"); + this.binaryVal = ByteBuffer.allocate(binaryVal.remaining()).put(binaryVal.duplicate()); + ((Buffer) this.binaryVal).rewind(); + return this; + } + + private void validatePrimitiveFieldsHaveBeenInitialized() { + List missingFields = null; + missingFields = addFieldIfMissing(missingFields, _intValInitialized, "intVal"); + missingFields = addFieldIfMissing(missingFields, _doubleValInitialized, "doubleVal"); + missingFields = addFieldIfMissing(missingFields, _boolValInitialized, "boolVal"); + if (missingFields != null) { + throw new SafeIllegalArgumentException( + "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); + } + } + + private static List addFieldIfMissing(List prev, boolean initialized, String fieldName) { + List missingFields = prev; + if (!initialized) { + if (missingFields == null) { + missingFields = new ArrayList<>(3); + } + missingFields.add(fieldName); + } + return missingFields; + } + + @CheckReturnValue + public PrimitiveExample build() { + checkNotBuilt(); + this._buildInvoked = true; + validatePrimitiveFieldsHaveBeenInitialized(); + return new PrimitiveExample( + stringVal, intVal, longVal, doubleVal, boolVal, ridVal, uuidVal, datetimeVal, binaryVal); + } + + private void checkNotBuilt() { + Preconditions.checkState(!_buildInvoked, "Build has already been called"); + } + } +} diff --git a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/SafetyExample.java b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/SafetyExample.java new file mode 100644 index 000000000..cf44cb5d0 --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/SafetyExample.java @@ -0,0 +1,176 @@ +package jersey.com.palantir.product; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonSetter; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import com.google.errorprone.annotations.CheckReturnValue; +import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.Safe; +import com.palantir.logsafe.SafeArg; +import com.palantir.logsafe.Unsafe; +import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; +import java.util.ArrayList; +import java.util.List; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import javax.annotation.processing.Generated; + +@Unsafe +@JsonDeserialize(builder = SafetyExample.Builder.class) +@Generated("com.palantir.conjure.java.types.BeanGenerator") +public final class SafetyExample { + private final String safeString; + + private final double unsafeDouble; + + private int memoizedHashCode; + + private SafetyExample(String safeString, double unsafeDouble) { + validateFields(safeString); + this.safeString = safeString; + this.unsafeDouble = unsafeDouble; + } + + @JsonProperty("safeString") + @Safe + public String getSafeString() { + return this.safeString; + } + + @JsonProperty("unsafeDouble") + @Unsafe + public double getUnsafeDouble() { + return this.unsafeDouble; + } + + @Override + public boolean equals(@Nullable Object other) { + return this == other || (other instanceof SafetyExample && equalTo((SafetyExample) other)); + } + + private boolean equalTo(SafetyExample other) { + if (this.memoizedHashCode != 0 + && other.memoizedHashCode != 0 + && this.memoizedHashCode != other.memoizedHashCode) { + return false; + } + return this.safeString.equals(other.safeString) + && Double.doubleToLongBits(this.unsafeDouble) == Double.doubleToLongBits(other.unsafeDouble); + } + + @Override + public int hashCode() { + int result = memoizedHashCode; + if (result == 0) { + int hash = 1; + hash = 31 * hash + this.safeString.hashCode(); + hash = 31 * hash + Double.hashCode(this.unsafeDouble); + result = hash; + memoizedHashCode = result; + } + return result; + } + + @Override + @Unsafe + public String toString() { + return "SafetyExample{safeString: " + safeString + ", unsafeDouble: " + unsafeDouble + '}'; + } + + public static SafetyExample of(@Safe String safeString, @Unsafe double unsafeDouble) { + return builder().safeString(safeString).unsafeDouble(unsafeDouble).build(); + } + + private static void validateFields(String safeString) { + List missingFields = null; + missingFields = addFieldIfMissing(missingFields, safeString, "safeString"); + if (missingFields != null) { + throw new SafeIllegalArgumentException( + "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); + } + } + + private static List addFieldIfMissing(List prev, Object fieldValue, String fieldName) { + List missingFields = prev; + if (fieldValue == null) { + if (missingFields == null) { + missingFields = new ArrayList<>(1); + } + missingFields.add(fieldName); + } + return missingFields; + } + + public static Builder builder() { + return new Builder(); + } + + @Generated("com.palantir.conjure.java.types.BeanBuilderGenerator") + @JsonIgnoreProperties(ignoreUnknown = true) + public static final class Builder { + boolean _buildInvoked; + + private @Safe String safeString; + + private @Unsafe double unsafeDouble; + + private boolean _unsafeDoubleInitialized = false; + + private Builder() {} + + public Builder from(SafetyExample other) { + checkNotBuilt(); + safeString(other.getSafeString()); + unsafeDouble(other.getUnsafeDouble()); + return this; + } + + @JsonSetter("safeString") + public Builder safeString(@Nonnull @Safe String safeString) { + checkNotBuilt(); + this.safeString = Preconditions.checkNotNull(safeString, "safeString cannot be null"); + return this; + } + + @JsonSetter("unsafeDouble") + public Builder unsafeDouble(@Unsafe double unsafeDouble) { + checkNotBuilt(); + this.unsafeDouble = unsafeDouble; + this._unsafeDoubleInitialized = true; + return this; + } + + private void validatePrimitiveFieldsHaveBeenInitialized() { + List missingFields = null; + missingFields = addFieldIfMissing(missingFields, _unsafeDoubleInitialized, "unsafeDouble"); + if (missingFields != null) { + throw new SafeIllegalArgumentException( + "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); + } + } + + private static List addFieldIfMissing(List prev, boolean initialized, String fieldName) { + List missingFields = prev; + if (!initialized) { + if (missingFields == null) { + missingFields = new ArrayList<>(1); + } + missingFields.add(fieldName); + } + return missingFields; + } + + @CheckReturnValue + public SafetyExample build() { + checkNotBuilt(); + this._buildInvoked = true; + validatePrimitiveFieldsHaveBeenInitialized(); + return new SafetyExample(safeString, unsafeDouble); + } + + private void checkNotBuilt() { + Preconditions.checkState(!_buildInvoked, "Build has already been called"); + } + } +} diff --git a/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/StringAlias.java b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/StringAliasEx.java similarity index 65% rename from conjure-java-core/src/integrationInput/java/errors/com/palantir/product/StringAlias.java rename to conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/StringAliasEx.java index 0eb940fc9..d979fb1f2 100644 --- a/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/StringAlias.java +++ b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/StringAliasEx.java @@ -1,4 +1,4 @@ -package errors.com.palantir.product; +package jersey.com.palantir.product; import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonValue; @@ -10,10 +10,10 @@ @Safe @Generated("com.palantir.conjure.java.types.AliasGenerator") -public final class StringAlias implements Comparable { +public final class StringAliasEx implements Comparable { private final @Safe String value; - private StringAlias(@Nonnull @Safe String value) { + private StringAliasEx(@Nonnull @Safe String value) { this.value = Preconditions.checkNotNull(value, "value cannot be null"); } @@ -30,10 +30,10 @@ public String toString() { @Override public boolean equals(@Nullable Object other) { - return this == other || (other instanceof StringAlias && equalTo((StringAlias) other)); + return this == other || (other instanceof StringAliasEx && equalTo((StringAliasEx) other)); } - private boolean equalTo(StringAlias other) { + private boolean equalTo(StringAliasEx other) { return this.value.equals(other.value); } @@ -43,16 +43,16 @@ public int hashCode() { } @Override - public int compareTo(StringAlias other) { + public int compareTo(StringAliasEx other) { return value.compareTo(other.get()); } - public static StringAlias valueOf(@Safe String value) { + public static StringAliasEx valueOf(@Safe String value) { return of(value); } @JsonCreator(mode = JsonCreator.Mode.DELEGATING) - public static StringAlias of(@Nonnull @Safe String value) { - return new StringAlias(value); + public static StringAliasEx of(@Nonnull @Safe String value) { + return new StringAliasEx(value); } } diff --git a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/UnionExample.java b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/UnionExample.java new file mode 100644 index 000000000..02dc9e822 --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/UnionExample.java @@ -0,0 +1,579 @@ +package jersey.com.palantir.product; + +import com.fasterxml.jackson.annotation.JsonAnyGetter; +import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonSetter; +import com.fasterxml.jackson.annotation.JsonSubTypes; +import com.fasterxml.jackson.annotation.JsonTypeInfo; +import com.fasterxml.jackson.annotation.JsonTypeName; +import com.fasterxml.jackson.annotation.JsonValue; +import com.fasterxml.jackson.annotation.Nulls; +import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.Safe; +import com.palantir.logsafe.SafeArg; +import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.function.Function; +import java.util.function.IntFunction; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import javax.annotation.processing.Generated; + +@Generated("com.palantir.conjure.java.types.UnionGenerator") +public final class UnionExample { + private final Base value; + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + private UnionExample(Base value) { + this.value = value; + } + + @JsonValue + private Base getValue() { + return value; + } + + public static UnionExample stringVariant(String value) { + return new UnionExample(new StringVariantWrapper(value)); + } + + public static UnionExample intVariant(int value) { + return new UnionExample(new IntVariantWrapper(value)); + } + + public static UnionExample objectVariant(ObjectReference value) { + return new UnionExample(new ObjectVariantWrapper(value)); + } + + public static UnionExample collectionVariant(List value) { + return new UnionExample(new CollectionVariantWrapper(value)); + } + + public static UnionExample optionalVariant(Optional value) { + return new UnionExample(new OptionalVariantWrapper(value)); + } + + public static UnionExample unknown(@Safe String type, Object value) { + switch (Preconditions.checkNotNull(type, "Type is required")) { + case "stringVariant": + throw new SafeIllegalArgumentException( + "Unknown type cannot be created as the provided type is known: stringVariant"); + case "intVariant": + throw new SafeIllegalArgumentException( + "Unknown type cannot be created as the provided type is known: intVariant"); + case "objectVariant": + throw new SafeIllegalArgumentException( + "Unknown type cannot be created as the provided type is known: objectVariant"); + case "collectionVariant": + throw new SafeIllegalArgumentException( + "Unknown type cannot be created as the provided type is known: collectionVariant"); + case "optionalVariant": + throw new SafeIllegalArgumentException( + "Unknown type cannot be created as the provided type is known: optionalVariant"); + default: + return new UnionExample(new UnknownWrapper(type, Collections.singletonMap(type, value))); + } + } + + public T accept(Visitor visitor) { + return value.accept(visitor); + } + + @Override + public boolean equals(@Nullable Object other) { + return this == other || (other instanceof UnionExample && equalTo((UnionExample) other)); + } + + private boolean equalTo(UnionExample other) { + return this.value.equals(other.value); + } + + @Override + public int hashCode() { + return this.value.hashCode(); + } + + @Override + public String toString() { + return "UnionExample{value: " + value + '}'; + } + + public interface Visitor { + T visitStringVariant(String value); + + T visitIntVariant(int value); + + T visitObjectVariant(ObjectReference value); + + T visitCollectionVariant(List value); + + T visitOptionalVariant(Optional value); + + T visitUnknown(@Safe String unknownType); + + static CollectionVariantStageVisitorBuilder builder() { + return new VisitorBuilder(); + } + } + + private static final class VisitorBuilder + implements CollectionVariantStageVisitorBuilder, + IntVariantStageVisitorBuilder, + ObjectVariantStageVisitorBuilder, + OptionalVariantStageVisitorBuilder, + StringVariantStageVisitorBuilder, + UnknownStageVisitorBuilder, + Completed_StageVisitorBuilder { + private Function, T> collectionVariantVisitor; + + private IntFunction intVariantVisitor; + + private Function objectVariantVisitor; + + private Function, T> optionalVariantVisitor; + + private Function stringVariantVisitor; + + private Function unknownVisitor; + + @Override + public IntVariantStageVisitorBuilder collectionVariant( + @Nonnull Function, T> collectionVariantVisitor) { + Preconditions.checkNotNull(collectionVariantVisitor, "collectionVariantVisitor cannot be null"); + this.collectionVariantVisitor = collectionVariantVisitor; + return this; + } + + @Override + public ObjectVariantStageVisitorBuilder intVariant(@Nonnull IntFunction intVariantVisitor) { + Preconditions.checkNotNull(intVariantVisitor, "intVariantVisitor cannot be null"); + this.intVariantVisitor = intVariantVisitor; + return this; + } + + @Override + public OptionalVariantStageVisitorBuilder objectVariant( + @Nonnull Function objectVariantVisitor) { + Preconditions.checkNotNull(objectVariantVisitor, "objectVariantVisitor cannot be null"); + this.objectVariantVisitor = objectVariantVisitor; + return this; + } + + @Override + public StringVariantStageVisitorBuilder optionalVariant( + @Nonnull Function, T> optionalVariantVisitor) { + Preconditions.checkNotNull(optionalVariantVisitor, "optionalVariantVisitor cannot be null"); + this.optionalVariantVisitor = optionalVariantVisitor; + return this; + } + + @Override + public UnknownStageVisitorBuilder stringVariant(@Nonnull Function stringVariantVisitor) { + Preconditions.checkNotNull(stringVariantVisitor, "stringVariantVisitor cannot be null"); + this.stringVariantVisitor = stringVariantVisitor; + return this; + } + + @Override + public Completed_StageVisitorBuilder unknown(@Nonnull Function unknownVisitor) { + Preconditions.checkNotNull(unknownVisitor, "unknownVisitor cannot be null"); + this.unknownVisitor = unknownVisitor; + return this; + } + + @Override + public Completed_StageVisitorBuilder throwOnUnknown() { + this.unknownVisitor = unknownType -> { + throw new SafeIllegalArgumentException( + "Unknown variant of the 'UnionExample' union", SafeArg.of("unknownType", unknownType)); + }; + return this; + } + + @Override + public Visitor build() { + final Function, T> collectionVariantVisitor = this.collectionVariantVisitor; + final IntFunction intVariantVisitor = this.intVariantVisitor; + final Function objectVariantVisitor = this.objectVariantVisitor; + final Function, T> optionalVariantVisitor = this.optionalVariantVisitor; + final Function stringVariantVisitor = this.stringVariantVisitor; + final Function unknownVisitor = this.unknownVisitor; + return new Visitor() { + @Override + public T visitCollectionVariant(List value) { + return collectionVariantVisitor.apply(value); + } + + @Override + public T visitIntVariant(int value) { + return intVariantVisitor.apply(value); + } + + @Override + public T visitObjectVariant(ObjectReference value) { + return objectVariantVisitor.apply(value); + } + + @Override + public T visitOptionalVariant(Optional value) { + return optionalVariantVisitor.apply(value); + } + + @Override + public T visitStringVariant(String value) { + return stringVariantVisitor.apply(value); + } + + @Override + public T visitUnknown(String value) { + return unknownVisitor.apply(value); + } + }; + } + } + + public interface CollectionVariantStageVisitorBuilder { + IntVariantStageVisitorBuilder collectionVariant(@Nonnull Function, T> collectionVariantVisitor); + } + + public interface IntVariantStageVisitorBuilder { + ObjectVariantStageVisitorBuilder intVariant(@Nonnull IntFunction intVariantVisitor); + } + + public interface ObjectVariantStageVisitorBuilder { + OptionalVariantStageVisitorBuilder objectVariant(@Nonnull Function objectVariantVisitor); + } + + public interface OptionalVariantStageVisitorBuilder { + StringVariantStageVisitorBuilder optionalVariant( + @Nonnull Function, T> optionalVariantVisitor); + } + + public interface StringVariantStageVisitorBuilder { + UnknownStageVisitorBuilder stringVariant(@Nonnull Function stringVariantVisitor); + } + + public interface UnknownStageVisitorBuilder { + Completed_StageVisitorBuilder unknown(@Nonnull Function unknownVisitor); + + Completed_StageVisitorBuilder throwOnUnknown(); + } + + public interface Completed_StageVisitorBuilder { + Visitor build(); + } + + @JsonTypeInfo( + use = JsonTypeInfo.Id.NAME, + include = JsonTypeInfo.As.EXISTING_PROPERTY, + property = "type", + visible = true, + defaultImpl = UnknownWrapper.class) + @JsonSubTypes({ + @JsonSubTypes.Type(StringVariantWrapper.class), + @JsonSubTypes.Type(IntVariantWrapper.class), + @JsonSubTypes.Type(ObjectVariantWrapper.class), + @JsonSubTypes.Type(CollectionVariantWrapper.class), + @JsonSubTypes.Type(OptionalVariantWrapper.class) + }) + @JsonIgnoreProperties(ignoreUnknown = true) + private interface Base { + T accept(Visitor visitor); + } + + @JsonTypeName("stringVariant") + private static final class StringVariantWrapper implements Base { + private final String value; + + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + private StringVariantWrapper(@JsonSetter("stringVariant") @Nonnull String value) { + Preconditions.checkNotNull(value, "stringVariant cannot be null"); + this.value = value; + } + + @JsonProperty(value = "type", index = 0) + private String getType() { + return "stringVariant"; + } + + @JsonProperty("stringVariant") + private String getValue() { + return value; + } + + @Override + public T accept(Visitor visitor) { + return visitor.visitStringVariant(value); + } + + @Override + public boolean equals(@Nullable Object other) { + return this == other || (other instanceof StringVariantWrapper && equalTo((StringVariantWrapper) other)); + } + + private boolean equalTo(StringVariantWrapper other) { + return this.value.equals(other.value); + } + + @Override + public int hashCode() { + return this.value.hashCode(); + } + + @Override + public String toString() { + return "StringVariantWrapper{value: " + value + '}'; + } + } + + @JsonTypeName("intVariant") + private static final class IntVariantWrapper implements Base { + private final int value; + + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + private IntVariantWrapper(@JsonSetter("intVariant") @Nonnull int value) { + Preconditions.checkNotNull(value, "intVariant cannot be null"); + this.value = value; + } + + @JsonProperty(value = "type", index = 0) + private String getType() { + return "intVariant"; + } + + @JsonProperty("intVariant") + private int getValue() { + return value; + } + + @Override + public T accept(Visitor visitor) { + return visitor.visitIntVariant(value); + } + + @Override + public boolean equals(@Nullable Object other) { + return this == other || (other instanceof IntVariantWrapper && equalTo((IntVariantWrapper) other)); + } + + private boolean equalTo(IntVariantWrapper other) { + return this.value == other.value; + } + + @Override + public int hashCode() { + return this.value; + } + + @Override + public String toString() { + return "IntVariantWrapper{value: " + value + '}'; + } + } + + @JsonTypeName("objectVariant") + private static final class ObjectVariantWrapper implements Base { + private final ObjectReference value; + + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + private ObjectVariantWrapper(@JsonSetter("objectVariant") @Nonnull ObjectReference value) { + Preconditions.checkNotNull(value, "objectVariant cannot be null"); + this.value = value; + } + + @JsonProperty(value = "type", index = 0) + private String getType() { + return "objectVariant"; + } + + @JsonProperty("objectVariant") + private ObjectReference getValue() { + return value; + } + + @Override + public T accept(Visitor visitor) { + return visitor.visitObjectVariant(value); + } + + @Override + public boolean equals(@Nullable Object other) { + return this == other || (other instanceof ObjectVariantWrapper && equalTo((ObjectVariantWrapper) other)); + } + + private boolean equalTo(ObjectVariantWrapper other) { + return this.value.equals(other.value); + } + + @Override + public int hashCode() { + return this.value.hashCode(); + } + + @Override + public String toString() { + return "ObjectVariantWrapper{value: " + value + '}'; + } + } + + @JsonTypeName("collectionVariant") + private static final class CollectionVariantWrapper implements Base { + private final List value; + + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + private CollectionVariantWrapper( + @JsonSetter(value = "collectionVariant", nulls = Nulls.AS_EMPTY) @Nonnull List value) { + Preconditions.checkNotNull(value, "collectionVariant cannot be null"); + this.value = value; + } + + @JsonProperty(value = "type", index = 0) + private String getType() { + return "collectionVariant"; + } + + @JsonProperty("collectionVariant") + private List getValue() { + return value; + } + + @Override + public T accept(Visitor visitor) { + return visitor.visitCollectionVariant(value); + } + + @Override + public boolean equals(@Nullable Object other) { + return this == other + || (other instanceof CollectionVariantWrapper && equalTo((CollectionVariantWrapper) other)); + } + + private boolean equalTo(CollectionVariantWrapper other) { + return this.value.equals(other.value); + } + + @Override + public int hashCode() { + return this.value.hashCode(); + } + + @Override + public String toString() { + return "CollectionVariantWrapper{value: " + value + '}'; + } + } + + @JsonTypeName("optionalVariant") + private static final class OptionalVariantWrapper implements Base { + private final Optional value; + + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + private OptionalVariantWrapper( + @JsonSetter(value = "optionalVariant", nulls = Nulls.AS_EMPTY) @Nonnull Optional value) { + Preconditions.checkNotNull(value, "optionalVariant cannot be null"); + this.value = value; + } + + @JsonProperty(value = "type", index = 0) + private String getType() { + return "optionalVariant"; + } + + @JsonProperty("optionalVariant") + private Optional getValue() { + return value; + } + + @Override + public T accept(Visitor visitor) { + return visitor.visitOptionalVariant(value); + } + + @Override + public boolean equals(@Nullable Object other) { + return this == other + || (other instanceof OptionalVariantWrapper && equalTo((OptionalVariantWrapper) other)); + } + + private boolean equalTo(OptionalVariantWrapper other) { + return this.value.equals(other.value); + } + + @Override + public int hashCode() { + return this.value.hashCode(); + } + + @Override + public String toString() { + return "OptionalVariantWrapper{value: " + value + '}'; + } + } + + private static final class UnknownWrapper implements Base { + private final String type; + + private final Map value; + + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + private UnknownWrapper(@JsonProperty("type") String type) { + this(type, new HashMap()); + } + + private UnknownWrapper(@Nonnull String type, @Nonnull Map value) { + Preconditions.checkNotNull(type, "type cannot be null"); + Preconditions.checkNotNull(value, "value cannot be null"); + this.type = type; + this.value = value; + } + + @JsonProperty + private String getType() { + return type; + } + + @JsonAnyGetter + private Map getValue() { + return value; + } + + @JsonAnySetter + private void put(String key, Object val) { + value.put(key, val); + } + + @Override + public T accept(Visitor visitor) { + return visitor.visitUnknown(type); + } + + @Override + public boolean equals(@Nullable Object other) { + return this == other || (other instanceof UnknownWrapper && equalTo((UnknownWrapper) other)); + } + + private boolean equalTo(UnknownWrapper other) { + return this.type.equals(other.type) && this.value.equals(other.value); + } + + @Override + public int hashCode() { + int hash = 1; + hash = 31 * hash + this.type.hashCode(); + hash = 31 * hash + this.value.hashCode(); + return hash; + } + + @Override + public String toString() { + return "UnknownWrapper{type: " + type + ", value: " + value + '}'; + } + } +} diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/another/ConjureErrors.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/another/ConjureErrors.java new file mode 100644 index 000000000..5ae29129e --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/another/ConjureErrors.java @@ -0,0 +1,87 @@ +package undertow.com.palantir.another; + +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.palantir.conjure.java.api.errors.AbstractSerializableError; +import com.palantir.conjure.java.api.errors.ErrorType; +import com.palantir.conjure.java.api.errors.RemoteException; +import com.palantir.conjure.java.api.errors.SerializableError; +import com.palantir.conjure.java.api.errors.ServiceException; +import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.Safe; +import javax.annotation.Nullable; +import javax.annotation.processing.Generated; +import org.jetbrains.annotations.Contract; + +@Generated("com.palantir.conjure.java.types.ErrorGenerator") +public final class ConjureErrors { + /** Different package. */ + public static final ErrorType DIFFERENT_PACKAGE_ERR = + ErrorType.create(ErrorType.Code.INTERNAL, "Conjure:DifferentPackageErr"); + + private ConjureErrors() {} + + public static ServiceException differentPackageErr() { + return new ServiceException(DIFFERENT_PACKAGE_ERR); + } + + public static ServiceException differentPackageErr(@Nullable Throwable cause) { + return new ServiceException(DIFFERENT_PACKAGE_ERR, cause); + } + + /** + * Throws a {@link ServiceException} of type DifferentPackageErr when {@code shouldThrow} is true. + * + * @param shouldThrow Cause the method to throw when true + */ + @Contract("true -> fail") + public static void throwIfDifferentPackageErr(boolean shouldThrow) { + if (shouldThrow) { + throw differentPackageErr(); + } + } + + /** Returns true if the {@link RemoteException} is named Conjure:DifferentPackageErr */ + public static boolean isDifferentPackageErr(RemoteException remoteException) { + Preconditions.checkNotNull(remoteException, "remote exception must not be null"); + return DIFFERENT_PACKAGE_ERR.name().equals(remoteException.getError().errorName()); + } + + public static record DifferentPackageErrParameters() {} + + public static final class DifferentPackageErrSerializableError + extends AbstractSerializableError { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + DifferentPackageErrSerializableError( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorName") @Safe String errorName, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") DifferentPackageErrParameters parameters) { + super(errorCode, errorName, errorInstanceId, parameters); + } + + public SerializableError toSerializableError() { + SerializableError.Builder builder = SerializableError.builder() + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()); + return builder.build(); + } + } + + public static final class DifferentPackageErrException extends RemoteException { + private DifferentPackageErrSerializableError error; + + private int status; + + public DifferentPackageErrException(DifferentPackageErrSerializableError error, int status) { + super(error.toSerializableError(), status); + this.error = error; + this.status = status; + } + + public DifferentPackageErrSerializableError error() { + return error; + } + } +} diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/AnyExample.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/AnyExample.java new file mode 100644 index 000000000..f852b517e --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/AnyExample.java @@ -0,0 +1,162 @@ +package undertow.com.palantir.product; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonSetter; +import com.fasterxml.jackson.annotation.Nulls; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import com.google.errorprone.annotations.CheckReturnValue; +import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.SafeArg; +import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; +import java.util.ArrayList; +import java.util.Collections; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import javax.annotation.processing.Generated; + +@JsonDeserialize(builder = AnyExample.Builder.class) +@Generated("com.palantir.conjure.java.types.BeanGenerator") +public final class AnyExample { + private final Object anyValue; + + private final Map anyMap; + + private int memoizedHashCode; + + private AnyExample(Object anyValue, Map anyMap) { + validateFields(anyValue, anyMap); + this.anyValue = anyValue; + this.anyMap = Collections.unmodifiableMap(anyMap); + } + + @JsonProperty("anyValue") + public Object getAnyValue() { + return this.anyValue; + } + + @JsonProperty("anyMap") + public Map getAnyMap() { + return this.anyMap; + } + + @Override + public boolean equals(@Nullable Object other) { + return this == other || (other instanceof AnyExample && equalTo((AnyExample) other)); + } + + private boolean equalTo(AnyExample other) { + if (this.memoizedHashCode != 0 + && other.memoizedHashCode != 0 + && this.memoizedHashCode != other.memoizedHashCode) { + return false; + } + return this.anyValue.equals(other.anyValue) && this.anyMap.equals(other.anyMap); + } + + @Override + public int hashCode() { + int result = memoizedHashCode; + if (result == 0) { + int hash = 1; + hash = 31 * hash + this.anyValue.hashCode(); + hash = 31 * hash + this.anyMap.hashCode(); + result = hash; + memoizedHashCode = result; + } + return result; + } + + @Override + public String toString() { + return "AnyExample{anyValue: " + anyValue + ", anyMap: " + anyMap + '}'; + } + + public static AnyExample of(Object anyValue, Map anyMap) { + return builder().anyValue(anyValue).anyMap(anyMap).build(); + } + + private static void validateFields(Object anyValue, Map anyMap) { + List missingFields = null; + missingFields = addFieldIfMissing(missingFields, anyValue, "anyValue"); + missingFields = addFieldIfMissing(missingFields, anyMap, "anyMap"); + if (missingFields != null) { + throw new SafeIllegalArgumentException( + "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); + } + } + + private static List addFieldIfMissing(List prev, Object fieldValue, String fieldName) { + List missingFields = prev; + if (fieldValue == null) { + if (missingFields == null) { + missingFields = new ArrayList<>(2); + } + missingFields.add(fieldName); + } + return missingFields; + } + + public static Builder builder() { + return new Builder(); + } + + @Generated("com.palantir.conjure.java.types.BeanBuilderGenerator") + @JsonIgnoreProperties(ignoreUnknown = true) + public static final class Builder { + boolean _buildInvoked; + + private Object anyValue; + + private Map anyMap = new LinkedHashMap<>(); + + private Builder() {} + + public Builder from(AnyExample other) { + checkNotBuilt(); + anyValue(other.getAnyValue()); + anyMap(other.getAnyMap()); + return this; + } + + @JsonSetter("anyValue") + public Builder anyValue(@Nonnull Object anyValue) { + checkNotBuilt(); + this.anyValue = Preconditions.checkNotNull(anyValue, "anyValue cannot be null"); + return this; + } + + @JsonSetter(value = "anyMap", nulls = Nulls.SKIP, contentNulls = Nulls.FAIL) + public Builder anyMap(@Nonnull Map anyMap) { + checkNotBuilt(); + this.anyMap = new LinkedHashMap<>(Preconditions.checkNotNull(anyMap, "anyMap cannot be null")); + return this; + } + + public Builder putAllAnyMap(@Nonnull Map anyMap) { + checkNotBuilt(); + this.anyMap.putAll(Preconditions.checkNotNull(anyMap, "anyMap cannot be null")); + return this; + } + + public Builder anyMap(String key, Object value) { + checkNotBuilt(); + this.anyMap.put(key, value); + return this; + } + + @CheckReturnValue + public AnyExample build() { + checkNotBuilt(); + this._buildInvoked = true; + return new AnyExample(anyValue, anyMap); + } + + private void checkNotBuilt() { + Preconditions.checkState(!_buildInvoked, "Build has already been called"); + } + } +} diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/CollectionAlias.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/CollectionAlias.java new file mode 100644 index 000000000..0771470b2 --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/CollectionAlias.java @@ -0,0 +1,70 @@ +package undertow.com.palantir.product; + +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonValue; +import com.palantir.logsafe.Preconditions; +import java.util.Collections; +import java.util.List; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import javax.annotation.processing.Generated; + +@Generated("com.palantir.conjure.java.types.AliasGenerator") +public final class CollectionAlias { + private static final CollectionAlias EMPTY = new CollectionAlias(); + + private final List value; + + private int memoizedHashCode; + + private CollectionAlias(@Nonnull List value) { + this.value = Preconditions.checkNotNull(value, "value cannot be null"); + } + + private CollectionAlias() { + this(Collections.emptyList()); + } + + @JsonValue + public List get() { + return value; + } + + @Override + public String toString() { + return value.toString(); + } + + @Override + public boolean equals(@Nullable Object other) { + return this == other || (other instanceof CollectionAlias && equalTo((CollectionAlias) other)); + } + + private boolean equalTo(CollectionAlias other) { + if (this.memoizedHashCode != 0 + && other.memoizedHashCode != 0 + && this.memoizedHashCode != other.memoizedHashCode) { + return false; + } + return this.value.equals(other.value); + } + + @Override + public int hashCode() { + int result = memoizedHashCode; + if (result == 0) { + result = this.value.hashCode(); + memoizedHashCode = result; + } + return result; + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static CollectionAlias of(@Nonnull List value) { + return new CollectionAlias(value); + } + + public static CollectionAlias empty() { + return EMPTY; + } +} diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/CollectionExample.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/CollectionExample.java new file mode 100644 index 000000000..43387ed33 --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/CollectionExample.java @@ -0,0 +1,221 @@ +package undertow.com.palantir.product; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonSetter; +import com.fasterxml.jackson.annotation.Nulls; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import com.google.errorprone.annotations.CheckReturnValue; +import com.palantir.conjure.java.lib.internal.ConjureCollections; +import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.SafeArg; +import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; +import java.util.ArrayList; +import java.util.Collections; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import javax.annotation.processing.Generated; + +@JsonDeserialize(builder = CollectionExample.Builder.class) +@Generated("com.palantir.conjure.java.types.BeanGenerator") +public final class CollectionExample { + private final List stringList; + + private final Set stringSet; + + private final Map stringMap; + + private int memoizedHashCode; + + private CollectionExample(List stringList, Set stringSet, Map stringMap) { + validateFields(stringList, stringSet, stringMap); + this.stringList = ConjureCollections.unmodifiableList(stringList); + this.stringSet = Collections.unmodifiableSet(stringSet); + this.stringMap = Collections.unmodifiableMap(stringMap); + } + + @JsonProperty("stringList") + public List getStringList() { + return this.stringList; + } + + @JsonProperty("stringSet") + public Set getStringSet() { + return this.stringSet; + } + + @JsonProperty("stringMap") + public Map getStringMap() { + return this.stringMap; + } + + @Override + public boolean equals(@Nullable Object other) { + return this == other || (other instanceof CollectionExample && equalTo((CollectionExample) other)); + } + + private boolean equalTo(CollectionExample other) { + if (this.memoizedHashCode != 0 + && other.memoizedHashCode != 0 + && this.memoizedHashCode != other.memoizedHashCode) { + return false; + } + return this.stringList.equals(other.stringList) + && this.stringSet.equals(other.stringSet) + && this.stringMap.equals(other.stringMap); + } + + @Override + public int hashCode() { + int result = memoizedHashCode; + if (result == 0) { + int hash = 1; + hash = 31 * hash + this.stringList.hashCode(); + hash = 31 * hash + this.stringSet.hashCode(); + hash = 31 * hash + this.stringMap.hashCode(); + result = hash; + memoizedHashCode = result; + } + return result; + } + + @Override + public String toString() { + return "CollectionExample{stringList: " + stringList + ", stringSet: " + stringSet + ", stringMap: " + stringMap + + '}'; + } + + public static CollectionExample of(List stringList, Set stringSet, Map stringMap) { + return builder() + .stringList(stringList) + .stringSet(stringSet) + .stringMap(stringMap) + .build(); + } + + private static void validateFields(List stringList, Set stringSet, Map stringMap) { + List missingFields = null; + missingFields = addFieldIfMissing(missingFields, stringList, "stringList"); + missingFields = addFieldIfMissing(missingFields, stringSet, "stringSet"); + missingFields = addFieldIfMissing(missingFields, stringMap, "stringMap"); + if (missingFields != null) { + throw new SafeIllegalArgumentException( + "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); + } + } + + private static List addFieldIfMissing(List prev, Object fieldValue, String fieldName) { + List missingFields = prev; + if (fieldValue == null) { + if (missingFields == null) { + missingFields = new ArrayList<>(3); + } + missingFields.add(fieldName); + } + return missingFields; + } + + public static Builder builder() { + return new Builder(); + } + + @Generated("com.palantir.conjure.java.types.BeanBuilderGenerator") + @JsonIgnoreProperties(ignoreUnknown = true) + public static final class Builder { + boolean _buildInvoked; + + private List stringList = ConjureCollections.newNonNullList(); + + private Set stringSet = ConjureCollections.newNonNullSet(); + + private Map stringMap = new LinkedHashMap<>(); + + private Builder() {} + + public Builder from(CollectionExample other) { + checkNotBuilt(); + stringList(other.getStringList()); + stringSet(other.getStringSet()); + stringMap(other.getStringMap()); + return this; + } + + @JsonSetter(value = "stringList", nulls = Nulls.SKIP, contentNulls = Nulls.FAIL) + public Builder stringList(@Nonnull Iterable stringList) { + checkNotBuilt(); + this.stringList = ConjureCollections.newNonNullList( + Preconditions.checkNotNull(stringList, "stringList cannot be null")); + return this; + } + + public Builder addAllStringList(@Nonnull Iterable stringList) { + checkNotBuilt(); + ConjureCollections.addAllAndCheckNonNull( + this.stringList, Preconditions.checkNotNull(stringList, "stringList cannot be null")); + return this; + } + + public Builder stringList(String stringList) { + checkNotBuilt(); + Preconditions.checkNotNull(stringList, "stringList cannot be null"); + this.stringList.add(stringList); + return this; + } + + @JsonSetter(value = "stringSet", nulls = Nulls.SKIP, contentNulls = Nulls.FAIL) + public Builder stringSet(@Nonnull Iterable stringSet) { + checkNotBuilt(); + this.stringSet = + ConjureCollections.newNonNullSet(Preconditions.checkNotNull(stringSet, "stringSet cannot be null")); + return this; + } + + public Builder addAllStringSet(@Nonnull Iterable stringSet) { + checkNotBuilt(); + ConjureCollections.addAllAndCheckNonNull( + this.stringSet, Preconditions.checkNotNull(stringSet, "stringSet cannot be null")); + return this; + } + + public Builder stringSet(String stringSet) { + checkNotBuilt(); + Preconditions.checkNotNull(stringSet, "stringSet cannot be null"); + this.stringSet.add(stringSet); + return this; + } + + @JsonSetter(value = "stringMap", nulls = Nulls.SKIP, contentNulls = Nulls.FAIL) + public Builder stringMap(@Nonnull Map stringMap) { + checkNotBuilt(); + this.stringMap = new LinkedHashMap<>(Preconditions.checkNotNull(stringMap, "stringMap cannot be null")); + return this; + } + + public Builder putAllStringMap(@Nonnull Map stringMap) { + checkNotBuilt(); + this.stringMap.putAll(Preconditions.checkNotNull(stringMap, "stringMap cannot be null")); + return this; + } + + public Builder stringMap(String key, String value) { + checkNotBuilt(); + this.stringMap.put(key, value); + return this; + } + + @CheckReturnValue + public CollectionExample build() { + checkNotBuilt(); + this._buildInvoked = true; + return new CollectionExample(stringList, stringSet, stringMap); + } + + private void checkNotBuilt() { + Preconditions.checkState(!_buildInvoked, "Build has already been called"); + } + } +} diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ComplexExample.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ComplexExample.java new file mode 100644 index 000000000..9c9e15fdb --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ComplexExample.java @@ -0,0 +1,237 @@ +package undertow.com.palantir.product; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonSetter; +import com.fasterxml.jackson.annotation.Nulls; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import com.google.errorprone.annotations.CheckReturnValue; +import com.palantir.conjure.java.lib.internal.ConjureCollections; +import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.SafeArg; +import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; +import java.util.ArrayList; +import java.util.Collections; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.function.Function; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import javax.annotation.processing.Generated; + +@JsonDeserialize(builder = ComplexExample.Builder.class) +@Generated("com.palantir.conjure.java.types.BeanGenerator") +public final class ComplexExample { + private final Map>> metadata; + + private final EnumExample status; + + private final List variants; + + private final Optional external; + + private int memoizedHashCode; + + private ComplexExample( + Map>> metadata, + EnumExample status, + List variants, + Optional external) { + validateFields(metadata, status, variants, external); + this.metadata = Collections.unmodifiableMap(metadata); + this.status = status; + this.variants = ConjureCollections.unmodifiableList(variants); + this.external = external; + } + + @JsonProperty("metadata") + public Map>> getMetadata() { + return this.metadata; + } + + @JsonProperty("status") + public EnumExample getStatus() { + return this.status; + } + + @JsonProperty("variants") + public List getVariants() { + return this.variants; + } + + @JsonProperty("external") + @JsonInclude(JsonInclude.Include.NON_ABSENT) + public Optional getExternal() { + return this.external; + } + + @Override + public boolean equals(@Nullable Object other) { + return this == other || (other instanceof ComplexExample && equalTo((ComplexExample) other)); + } + + private boolean equalTo(ComplexExample other) { + if (this.memoizedHashCode != 0 + && other.memoizedHashCode != 0 + && this.memoizedHashCode != other.memoizedHashCode) { + return false; + } + return this.metadata.equals(other.metadata) + && this.status.equals(other.status) + && this.variants.equals(other.variants) + && this.external.equals(other.external); + } + + @Override + public int hashCode() { + int result = memoizedHashCode; + if (result == 0) { + int hash = 1; + hash = 31 * hash + this.metadata.hashCode(); + hash = 31 * hash + this.status.hashCode(); + hash = 31 * hash + this.variants.hashCode(); + hash = 31 * hash + this.external.hashCode(); + result = hash; + memoizedHashCode = result; + } + return result; + } + + @Override + public String toString() { + return "ComplexExample{metadata: " + metadata + ", status: " + status + ", variants: " + variants + + ", external: " + external + '}'; + } + + private static void validateFields( + Map>> metadata, + EnumExample status, + List variants, + Optional external) { + List missingFields = null; + missingFields = addFieldIfMissing(missingFields, metadata, "metadata"); + missingFields = addFieldIfMissing(missingFields, status, "status"); + missingFields = addFieldIfMissing(missingFields, variants, "variants"); + missingFields = addFieldIfMissing(missingFields, external, "external"); + if (missingFields != null) { + throw new SafeIllegalArgumentException( + "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); + } + } + + private static List addFieldIfMissing(List prev, Object fieldValue, String fieldName) { + List missingFields = prev; + if (fieldValue == null) { + if (missingFields == null) { + missingFields = new ArrayList<>(4); + } + missingFields.add(fieldName); + } + return missingFields; + } + + public static Builder builder() { + return new Builder(); + } + + @Generated("com.palantir.conjure.java.types.BeanBuilderGenerator") + @JsonIgnoreProperties(ignoreUnknown = true) + public static final class Builder { + boolean _buildInvoked; + + private Map>> metadata = new LinkedHashMap<>(); + + private EnumExample status; + + private List variants = ConjureCollections.newNonNullList(); + + private Optional external = Optional.empty(); + + private Builder() {} + + public Builder from(ComplexExample other) { + checkNotBuilt(); + metadata(other.getMetadata()); + status(other.getStatus()); + variants(other.getVariants()); + external(other.getExternal()); + return this; + } + + @JsonSetter(value = "metadata", nulls = Nulls.SKIP, contentNulls = Nulls.AS_EMPTY) + public Builder metadata(@Nonnull Map>> metadata) { + checkNotBuilt(); + this.metadata = new LinkedHashMap<>(Preconditions.checkNotNull(metadata, "metadata cannot be null")); + return this; + } + + public Builder putAllMetadata(@Nonnull Map>> metadata) { + checkNotBuilt(); + this.metadata.putAll(Preconditions.checkNotNull(metadata, "metadata cannot be null")); + return this; + } + + public Builder metadata(StringAliasEx key, Optional> value) { + checkNotBuilt(); + this.metadata.put(key, value); + return this; + } + + @JsonSetter("status") + public Builder status(@Nonnull EnumExample status) { + checkNotBuilt(); + this.status = Preconditions.checkNotNull(status, "status cannot be null"); + return this; + } + + @JsonSetter(value = "variants", nulls = Nulls.SKIP, contentNulls = Nulls.FAIL) + public Builder variants(@Nonnull Iterable variants) { + checkNotBuilt(); + this.variants = + ConjureCollections.newNonNullList(Preconditions.checkNotNull(variants, "variants cannot be null")); + return this; + } + + public Builder addAllVariants(@Nonnull Iterable variants) { + checkNotBuilt(); + ConjureCollections.addAllAndCheckNonNull( + this.variants, Preconditions.checkNotNull(variants, "variants cannot be null")); + return this; + } + + public Builder variants(UnionExample variants) { + checkNotBuilt(); + Preconditions.checkNotNull(variants, "variants cannot be null"); + this.variants.add(variants); + return this; + } + + @JsonSetter(value = "external", nulls = Nulls.SKIP) + public Builder external(@Nonnull Optional external) { + checkNotBuilt(); + this.external = Preconditions.checkNotNull(external, "external cannot be null") + .map(Function.identity()); + return this; + } + + public Builder external(long external) { + checkNotBuilt(); + this.external = Optional.of(Preconditions.checkNotNull(external, "external cannot be null")); + return this; + } + + @CheckReturnValue + public ComplexExample build() { + checkNotBuilt(); + this._buildInvoked = true; + return new ComplexExample(metadata, status, variants, external); + } + + private void checkNotBuilt() { + Preconditions.checkState(!_buildInvoked, "Build has already been called"); + } + } +} diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ConjureErrors.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ConjureErrors.java index 443cebc86..aad81d9cc 100644 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ConjureErrors.java +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ConjureErrors.java @@ -6,10 +6,16 @@ import com.palantir.conjure.java.api.errors.ErrorType; import com.palantir.conjure.java.api.errors.RemoteException; import com.palantir.conjure.java.api.errors.SerializableError; +import com.palantir.conjure.java.api.errors.ServiceException; import com.palantir.logsafe.Preconditions; import com.palantir.logsafe.Safe; +import com.palantir.logsafe.SafeArg; +import com.palantir.logsafe.Unsafe; +import com.palantir.logsafe.UnsafeArg; import java.util.Objects; +import javax.annotation.Nullable; import javax.annotation.processing.Generated; +import org.jetbrains.annotations.Contract; @Generated("com.palantir.conjure.java.types.ErrorGenerator") public final class ConjureErrors { @@ -17,8 +23,287 @@ public final class ConjureErrors { public static final ErrorType CONFLICTING_CAUSE_SAFE_ARG = ErrorType.create(ErrorType.Code.INTERNAL, "Conjure:ConflictingCauseSafeArg"); + /** Cause argument conflicts with reserved Throwable cause parameter. */ + public static final ErrorType CONFLICTING_CAUSE_SAFE_ARG_ERR = + ErrorType.create(ErrorType.Code.INTERNAL, "Conjure:ConflictingCauseSafeArgErr"); + + /** Cause argument conflicts with reserved Throwable cause parameter. */ + public static final ErrorType CONFLICTING_CAUSE_UNSAFE_ARG = + ErrorType.create(ErrorType.Code.INTERNAL, "Conjure:ConflictingCauseUnsafeArg"); + + public static final ErrorType ERROR_WITH_COMPLEX_ARGS = + ErrorType.create(ErrorType.Code.INTERNAL, "Conjure:ErrorWithComplexArgs"); + + /** Invalid Conjure service definition. */ + public static final ErrorType INVALID_SERVICE_DEFINITION = + ErrorType.create(ErrorType.Code.INVALID_ARGUMENT, "Conjure:InvalidServiceDefinition"); + + /** Invalid Conjure type definition. */ + public static final ErrorType INVALID_TYPE_DEFINITION = + ErrorType.create(ErrorType.Code.INVALID_ARGUMENT, "Conjure:InvalidTypeDefinition"); + private ConjureErrors() {} + public static ServiceException conflictingCauseSafeArg(@Safe String cause_, @Safe boolean shouldThrow_) { + return new ServiceException( + CONFLICTING_CAUSE_SAFE_ARG, SafeArg.of("cause", cause_), SafeArg.of("shouldThrow", shouldThrow_)); + } + + public static ServiceException conflictingCauseSafeArg( + @Nullable Throwable cause, @Safe String cause_, @Safe boolean shouldThrow_) { + return new ServiceException( + CONFLICTING_CAUSE_SAFE_ARG, + cause, + SafeArg.of("cause", cause_), + SafeArg.of("shouldThrow", shouldThrow_)); + } + + public static ServiceException conflictingCauseUnsafeArg(@Unsafe String cause_, @Unsafe boolean shouldThrow_) { + return new ServiceException( + CONFLICTING_CAUSE_UNSAFE_ARG, UnsafeArg.of("cause", cause_), UnsafeArg.of("shouldThrow", shouldThrow_)); + } + + public static ServiceException conflictingCauseUnsafeArg( + @Nullable Throwable cause, @Unsafe String cause_, @Unsafe boolean shouldThrow_) { + return new ServiceException( + CONFLICTING_CAUSE_UNSAFE_ARG, + cause, + UnsafeArg.of("cause", cause_), + UnsafeArg.of("shouldThrow", shouldThrow_)); + } + + public static ServiceException errorWithComplexArgs( + @Safe PrimitiveExample primitiveExample, + @Safe CollectionExample collectionExample, + @Safe NestedCollectionExample nestedCollectionExample, + @Safe OptionalExample optionalExample, + @Safe ObjectReference objectReference, + @Safe UnionExample unionExample, + @Safe EnumExample enumExample, + @Safe StringAliasEx stringAlias, + @Safe OptionalAlias optionalAlias, + @Safe CollectionAlias collectionAlias, + @Safe NestedAlias nestedAlias, + @Safe ExternalExample externalExample, + @Safe AnyExample anyExample, + @Safe EmptyObject emptyObject, + @Safe ComplexExample complexExample, + @Unsafe SafetyExample safetyExample) { + return new ServiceException( + ERROR_WITH_COMPLEX_ARGS, + SafeArg.of("primitiveExample", primitiveExample), + SafeArg.of("collectionExample", collectionExample), + SafeArg.of("nestedCollectionExample", nestedCollectionExample), + SafeArg.of("optionalExample", optionalExample), + SafeArg.of("objectReference", objectReference), + SafeArg.of("unionExample", unionExample), + SafeArg.of("enumExample", enumExample), + SafeArg.of("stringAlias", stringAlias), + SafeArg.of("optionalAlias", optionalAlias), + SafeArg.of("collectionAlias", collectionAlias), + SafeArg.of("nestedAlias", nestedAlias), + SafeArg.of("externalExample", externalExample), + SafeArg.of("anyExample", anyExample), + SafeArg.of("emptyObject", emptyObject), + SafeArg.of("complexExample", complexExample), + UnsafeArg.of("safetyExample", safetyExample)); + } + + public static ServiceException errorWithComplexArgs( + @Nullable Throwable cause, + @Safe PrimitiveExample primitiveExample, + @Safe CollectionExample collectionExample, + @Safe NestedCollectionExample nestedCollectionExample, + @Safe OptionalExample optionalExample, + @Safe ObjectReference objectReference, + @Safe UnionExample unionExample, + @Safe EnumExample enumExample, + @Safe StringAliasEx stringAlias, + @Safe OptionalAlias optionalAlias, + @Safe CollectionAlias collectionAlias, + @Safe NestedAlias nestedAlias, + @Safe ExternalExample externalExample, + @Safe AnyExample anyExample, + @Safe EmptyObject emptyObject, + @Safe ComplexExample complexExample, + @Unsafe SafetyExample safetyExample) { + return new ServiceException( + ERROR_WITH_COMPLEX_ARGS, + cause, + SafeArg.of("primitiveExample", primitiveExample), + SafeArg.of("collectionExample", collectionExample), + SafeArg.of("nestedCollectionExample", nestedCollectionExample), + SafeArg.of("optionalExample", optionalExample), + SafeArg.of("objectReference", objectReference), + SafeArg.of("unionExample", unionExample), + SafeArg.of("enumExample", enumExample), + SafeArg.of("stringAlias", stringAlias), + SafeArg.of("optionalAlias", optionalAlias), + SafeArg.of("collectionAlias", collectionAlias), + SafeArg.of("nestedAlias", nestedAlias), + SafeArg.of("externalExample", externalExample), + SafeArg.of("anyExample", anyExample), + SafeArg.of("emptyObject", emptyObject), + SafeArg.of("complexExample", complexExample), + UnsafeArg.of("safetyExample", safetyExample)); + } + + /** + * @param serviceName Name of the invalid service definition. + * @param serviceDef Details of the invalid service definition. + */ + public static ServiceException invalidServiceDefinition(@Safe String serviceName, @Unsafe Object serviceDef) { + return new ServiceException( + INVALID_SERVICE_DEFINITION, + SafeArg.of("serviceName", serviceName), + UnsafeArg.of("serviceDef", serviceDef)); + } + + /** + * @param serviceName Name of the invalid service definition. + * @param serviceDef Details of the invalid service definition. + */ + public static ServiceException invalidServiceDefinition( + @Nullable Throwable cause, @Safe String serviceName, @Unsafe Object serviceDef) { + return new ServiceException( + INVALID_SERVICE_DEFINITION, + cause, + SafeArg.of("serviceName", serviceName), + UnsafeArg.of("serviceDef", serviceDef)); + } + + public static ServiceException invalidTypeDefinition(@Safe String typeName, @Unsafe Object typeDef) { + return new ServiceException( + INVALID_TYPE_DEFINITION, SafeArg.of("typeName", typeName), UnsafeArg.of("typeDef", typeDef)); + } + + public static ServiceException invalidTypeDefinition( + @Nullable Throwable cause, @Safe String typeName, @Unsafe Object typeDef) { + return new ServiceException( + INVALID_TYPE_DEFINITION, cause, SafeArg.of("typeName", typeName), UnsafeArg.of("typeDef", typeDef)); + } + + /** + * Throws a {@link ServiceException} of type ConflictingCauseSafeArg when {@code shouldThrow} is true. + * + * @param shouldThrow Cause the method to throw when true + * @param cause_ + * @param shouldThrow_ + */ + @Contract("true, _, _ -> fail") + public static void throwIfConflictingCauseSafeArg( + boolean shouldThrow, @Safe String cause_, @Safe boolean shouldThrow_) { + if (shouldThrow) { + throw conflictingCauseSafeArg(cause_, shouldThrow_); + } + } + + /** + * Throws a {@link ServiceException} of type ConflictingCauseUnsafeArg when {@code shouldThrow} is true. + * + * @param shouldThrow Cause the method to throw when true + * @param cause_ + * @param shouldThrow_ + */ + @Contract("true, _, _ -> fail") + public static void throwIfConflictingCauseUnsafeArg( + boolean shouldThrow, @Unsafe String cause_, @Unsafe boolean shouldThrow_) { + if (shouldThrow) { + throw conflictingCauseUnsafeArg(cause_, shouldThrow_); + } + } + + /** + * Throws a {@link ServiceException} of type ErrorWithComplexArgs when {@code shouldThrow} is true. + * + * @param shouldThrow Cause the method to throw when true + * @param primitiveExample + * @param collectionExample + * @param nestedCollectionExample + * @param optionalExample + * @param objectReference + * @param unionExample + * @param enumExample + * @param stringAlias + * @param optionalAlias + * @param collectionAlias + * @param nestedAlias + * @param externalExample + * @param anyExample + * @param emptyObject + * @param complexExample + * @param safetyExample + */ + @Contract("true, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ -> fail") + public static void throwIfErrorWithComplexArgs( + boolean shouldThrow, + @Safe PrimitiveExample primitiveExample, + @Safe CollectionExample collectionExample, + @Safe NestedCollectionExample nestedCollectionExample, + @Safe OptionalExample optionalExample, + @Safe ObjectReference objectReference, + @Safe UnionExample unionExample, + @Safe EnumExample enumExample, + @Safe StringAliasEx stringAlias, + @Safe OptionalAlias optionalAlias, + @Safe CollectionAlias collectionAlias, + @Safe NestedAlias nestedAlias, + @Safe ExternalExample externalExample, + @Safe AnyExample anyExample, + @Safe EmptyObject emptyObject, + @Safe ComplexExample complexExample, + @Unsafe SafetyExample safetyExample) { + if (shouldThrow) { + throw errorWithComplexArgs( + primitiveExample, + collectionExample, + nestedCollectionExample, + optionalExample, + objectReference, + unionExample, + enumExample, + stringAlias, + optionalAlias, + collectionAlias, + nestedAlias, + externalExample, + anyExample, + emptyObject, + complexExample, + safetyExample); + } + } + + /** + * Throws a {@link ServiceException} of type InvalidServiceDefinition when {@code shouldThrow} is true. + * + * @param shouldThrow Cause the method to throw when true + * @param serviceName Name of the invalid service definition. + * @param serviceDef Details of the invalid service definition. + */ + @Contract("true, _, _ -> fail") + public static void throwIfInvalidServiceDefinition( + boolean shouldThrow, @Safe String serviceName, @Unsafe Object serviceDef) { + if (shouldThrow) { + throw invalidServiceDefinition(serviceName, serviceDef); + } + } + + /** + * Throws a {@link ServiceException} of type InvalidTypeDefinition when {@code shouldThrow} is true. + * + * @param shouldThrow Cause the method to throw when true + * @param typeName + * @param typeDef + */ + @Contract("true, _, _ -> fail") + public static void throwIfInvalidTypeDefinition( + boolean shouldThrow, @Safe String typeName, @Unsafe Object typeDef) { + if (shouldThrow) { + throw invalidTypeDefinition(typeName, typeDef); + } + } + /** Returns true if the {@link RemoteException} is named Conjure:ConflictingCauseSafeArg */ public static boolean isConflictingCauseSafeArg(RemoteException remoteException) { Preconditions.checkNotNull(remoteException, "remote exception must not be null"); @@ -27,9 +312,80 @@ public static boolean isConflictingCauseSafeArg(RemoteException remoteException) .equals(remoteException.getError().errorName()); } + /** Returns true if the {@link RemoteException} is named Conjure:ConflictingCauseSafeArgErr */ + public static boolean isConflictingCauseSafeArgErr(RemoteException remoteException) { + Preconditions.checkNotNull(remoteException, "remote exception must not be null"); + return CONFLICTING_CAUSE_SAFE_ARG_ERR + .name() + .equals(remoteException.getError().errorName()); + } + + /** Returns true if the {@link RemoteException} is named Conjure:ConflictingCauseUnsafeArg */ + public static boolean isConflictingCauseUnsafeArg(RemoteException remoteException) { + Preconditions.checkNotNull(remoteException, "remote exception must not be null"); + return CONFLICTING_CAUSE_UNSAFE_ARG + .name() + .equals(remoteException.getError().errorName()); + } + + /** Returns true if the {@link RemoteException} is named Conjure:ErrorWithComplexArgs */ + public static boolean isErrorWithComplexArgs(RemoteException remoteException) { + Preconditions.checkNotNull(remoteException, "remote exception must not be null"); + return ERROR_WITH_COMPLEX_ARGS.name().equals(remoteException.getError().errorName()); + } + + /** Returns true if the {@link RemoteException} is named Conjure:InvalidServiceDefinition */ + public static boolean isInvalidServiceDefinition(RemoteException remoteException) { + Preconditions.checkNotNull(remoteException, "remote exception must not be null"); + return INVALID_SERVICE_DEFINITION + .name() + .equals(remoteException.getError().errorName()); + } + + /** Returns true if the {@link RemoteException} is named Conjure:InvalidTypeDefinition */ + public static boolean isInvalidTypeDefinition(RemoteException remoteException) { + Preconditions.checkNotNull(remoteException, "remote exception must not be null"); + return INVALID_TYPE_DEFINITION.name().equals(remoteException.getError().errorName()); + } + public static record ConflictingCauseSafeArgParameters( @JsonProperty("cause") @Safe String cause_, @JsonProperty("shouldThrow") @Safe boolean shouldThrow_) {} + public static record ConflictingCauseSafeArgErrParameters( + @JsonProperty("cause") @Safe String cause_, @JsonProperty("shouldThrow") @Safe boolean shouldThrow_) {} + + public static record ConflictingCauseUnsafeArgParameters( + @JsonProperty("cause") @Unsafe String cause_, @JsonProperty("shouldThrow") @Unsafe boolean shouldThrow_) {} + + public static record ErrorWithComplexArgsParameters( + @JsonProperty("primitiveExample") @Safe PrimitiveExample primitiveExample, + @JsonProperty("collectionExample") @Safe CollectionExample collectionExample, + @JsonProperty("nestedCollectionExample") @Safe NestedCollectionExample nestedCollectionExample, + @JsonProperty("optionalExample") @Safe OptionalExample optionalExample, + @JsonProperty("objectReference") @Safe ObjectReference objectReference, + @JsonProperty("unionExample") @Safe UnionExample unionExample, + @JsonProperty("enumExample") @Safe EnumExample enumExample, + @JsonProperty("stringAlias") @Safe StringAliasEx stringAlias, + @JsonProperty("optionalAlias") @Safe OptionalAlias optionalAlias, + @JsonProperty("collectionAlias") @Safe CollectionAlias collectionAlias, + @JsonProperty("nestedAlias") @Safe NestedAlias nestedAlias, + @JsonProperty("externalExample") @Safe ExternalExample externalExample, + @JsonProperty("anyExample") @Safe AnyExample anyExample, + @JsonProperty("emptyObject") @Safe EmptyObject emptyObject, + @JsonProperty("complexExample") @Safe ComplexExample complexExample, + @JsonProperty("safetyExample") @Unsafe SafetyExample safetyExample) {} + + /** + * @param serviceName Name of the invalid service definition. + * @param serviceDef Details of the invalid service definition. + */ + public static record InvalidServiceDefinitionParameters( + @JsonProperty("serviceName") @Safe String serviceName, + @JsonProperty("serviceDef") @Unsafe Object serviceDef) {} + + public static record InvalidTypeDefinitionParameters( + @JsonProperty("typeName") @Safe String typeName, @JsonProperty("typeDef") @Unsafe Object typeDef) {} + public static final class ConflictingCauseSafeArgSerializableError extends AbstractSerializableError { @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) @@ -52,6 +408,141 @@ public SerializableError toSerializableError() { } } + public static final class ConflictingCauseSafeArgErrSerializableError + extends AbstractSerializableError { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + ConflictingCauseSafeArgErrSerializableError( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorName") @Safe String errorName, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") ConflictingCauseSafeArgErrParameters parameters) { + super(errorCode, errorName, errorInstanceId, parameters); + } + + public SerializableError toSerializableError() { + SerializableError.Builder builder = SerializableError.builder() + .putParameters("cause", Objects.toString(parameters().cause_())) + .putParameters("shouldThrow", Objects.toString(parameters().shouldThrow_())) + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()); + return builder.build(); + } + } + + public static final class ConflictingCauseUnsafeArgSerializableError + extends AbstractSerializableError { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + ConflictingCauseUnsafeArgSerializableError( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorName") @Safe String errorName, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") ConflictingCauseUnsafeArgParameters parameters) { + super(errorCode, errorName, errorInstanceId, parameters); + } + + public SerializableError toSerializableError() { + SerializableError.Builder builder = SerializableError.builder() + .putParameters("cause", Objects.toString(parameters().cause_())) + .putParameters("shouldThrow", Objects.toString(parameters().shouldThrow_())) + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()); + return builder.build(); + } + } + + public static final class ErrorWithComplexArgsSerializableError + extends AbstractSerializableError { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + ErrorWithComplexArgsSerializableError( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorName") @Safe String errorName, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") ErrorWithComplexArgsParameters parameters) { + super(errorCode, errorName, errorInstanceId, parameters); + } + + public SerializableError toSerializableError() { + SerializableError.Builder builder = SerializableError.builder() + .putParameters( + "primitiveExample", Objects.toString(parameters().primitiveExample())) + .putParameters( + "collectionExample", Objects.toString(parameters().collectionExample())) + .putParameters( + "nestedCollectionExample", + Objects.toString(parameters().nestedCollectionExample())) + .putParameters( + "optionalExample", Objects.toString(parameters().optionalExample())) + .putParameters( + "objectReference", Objects.toString(parameters().objectReference())) + .putParameters("unionExample", Objects.toString(parameters().unionExample())) + .putParameters("enumExample", Objects.toString(parameters().enumExample())) + .putParameters("stringAlias", Objects.toString(parameters().stringAlias())) + .putParameters( + "optionalAlias", Objects.toString(parameters().optionalAlias())) + .putParameters( + "collectionAlias", Objects.toString(parameters().collectionAlias())) + .putParameters("nestedAlias", Objects.toString(parameters().nestedAlias())) + .putParameters( + "externalExample", Objects.toString(parameters().externalExample())) + .putParameters("anyExample", Objects.toString(parameters().anyExample())) + .putParameters("emptyObject", Objects.toString(parameters().emptyObject())) + .putParameters( + "complexExample", Objects.toString(parameters().complexExample())) + .putParameters( + "safetyExample", Objects.toString(parameters().safetyExample())) + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()); + return builder.build(); + } + } + + public static final class InvalidServiceDefinitionSerializableError + extends AbstractSerializableError { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + InvalidServiceDefinitionSerializableError( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorName") @Safe String errorName, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") InvalidServiceDefinitionParameters parameters) { + super(errorCode, errorName, errorInstanceId, parameters); + } + + public SerializableError toSerializableError() { + SerializableError.Builder builder = SerializableError.builder() + .putParameters("serviceName", Objects.toString(parameters().serviceName())) + .putParameters("serviceDef", Objects.toString(parameters().serviceDef())) + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()); + return builder.build(); + } + } + + public static final class InvalidTypeDefinitionSerializableError + extends AbstractSerializableError { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + InvalidTypeDefinitionSerializableError( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorName") @Safe String errorName, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") InvalidTypeDefinitionParameters parameters) { + super(errorCode, errorName, errorInstanceId, parameters); + } + + public SerializableError toSerializableError() { + SerializableError.Builder builder = SerializableError.builder() + .putParameters("typeName", Objects.toString(parameters().typeName())) + .putParameters("typeDef", Objects.toString(parameters().typeDef())) + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()); + return builder.build(); + } + } + public static final class ConflictingCauseSafeArgException extends RemoteException { private ConflictingCauseSafeArgSerializableError error; @@ -67,4 +558,84 @@ public ConflictingCauseSafeArgSerializableError error() { return error; } } + + public static final class ConflictingCauseSafeArgErrException extends RemoteException { + private ConflictingCauseSafeArgErrSerializableError error; + + private int status; + + public ConflictingCauseSafeArgErrException(ConflictingCauseSafeArgErrSerializableError error, int status) { + super(error.toSerializableError(), status); + this.error = error; + this.status = status; + } + + public ConflictingCauseSafeArgErrSerializableError error() { + return error; + } + } + + public static final class ConflictingCauseUnsafeArgException extends RemoteException { + private ConflictingCauseUnsafeArgSerializableError error; + + private int status; + + public ConflictingCauseUnsafeArgException(ConflictingCauseUnsafeArgSerializableError error, int status) { + super(error.toSerializableError(), status); + this.error = error; + this.status = status; + } + + public ConflictingCauseUnsafeArgSerializableError error() { + return error; + } + } + + public static final class ErrorWithComplexArgsException extends RemoteException { + private ErrorWithComplexArgsSerializableError error; + + private int status; + + public ErrorWithComplexArgsException(ErrorWithComplexArgsSerializableError error, int status) { + super(error.toSerializableError(), status); + this.error = error; + this.status = status; + } + + public ErrorWithComplexArgsSerializableError error() { + return error; + } + } + + public static final class InvalidServiceDefinitionException extends RemoteException { + private InvalidServiceDefinitionSerializableError error; + + private int status; + + public InvalidServiceDefinitionException(InvalidServiceDefinitionSerializableError error, int status) { + super(error.toSerializableError(), status); + this.error = error; + this.status = status; + } + + public InvalidServiceDefinitionSerializableError error() { + return error; + } + } + + public static final class InvalidTypeDefinitionException extends RemoteException { + private InvalidTypeDefinitionSerializableError error; + + private int status; + + public InvalidTypeDefinitionException(InvalidTypeDefinitionSerializableError error, int status) { + super(error.toSerializableError(), status); + this.error = error; + this.status = status; + } + + public InvalidTypeDefinitionSerializableError error() { + return error; + } + } } diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ConjureJavaErrors.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ConjureJavaErrors.java new file mode 100644 index 000000000..b7bb11d6a --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ConjureJavaErrors.java @@ -0,0 +1,87 @@ +package undertow.com.palantir.product; + +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.palantir.conjure.java.api.errors.AbstractSerializableError; +import com.palantir.conjure.java.api.errors.ErrorType; +import com.palantir.conjure.java.api.errors.RemoteException; +import com.palantir.conjure.java.api.errors.SerializableError; +import com.palantir.conjure.java.api.errors.ServiceException; +import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.Safe; +import javax.annotation.Nullable; +import javax.annotation.processing.Generated; +import org.jetbrains.annotations.Contract; + +@Generated("com.palantir.conjure.java.types.ErrorGenerator") +public final class ConjureJavaErrors { + /** Failed to compile Conjure definition to Java code. */ + public static final ErrorType JAVA_COMPILATION_FAILED = + ErrorType.create(ErrorType.Code.INTERNAL, "ConjureJava:JavaCompilationFailed"); + + private ConjureJavaErrors() {} + + public static ServiceException javaCompilationFailed() { + return new ServiceException(JAVA_COMPILATION_FAILED); + } + + public static ServiceException javaCompilationFailed(@Nullable Throwable cause) { + return new ServiceException(JAVA_COMPILATION_FAILED, cause); + } + + /** + * Throws a {@link ServiceException} of type JavaCompilationFailed when {@code shouldThrow} is true. + * + * @param shouldThrow Cause the method to throw when true + */ + @Contract("true -> fail") + public static void throwIfJavaCompilationFailed(boolean shouldThrow) { + if (shouldThrow) { + throw javaCompilationFailed(); + } + } + + /** Returns true if the {@link RemoteException} is named ConjureJava:JavaCompilationFailed */ + public static boolean isJavaCompilationFailed(RemoteException remoteException) { + Preconditions.checkNotNull(remoteException, "remote exception must not be null"); + return JAVA_COMPILATION_FAILED.name().equals(remoteException.getError().errorName()); + } + + public static record JavaCompilationFailedParameters() {} + + public static final class JavaCompilationFailedSerializableError + extends AbstractSerializableError { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + JavaCompilationFailedSerializableError( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorName") @Safe String errorName, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") JavaCompilationFailedParameters parameters) { + super(errorCode, errorName, errorInstanceId, parameters); + } + + public SerializableError toSerializableError() { + SerializableError.Builder builder = SerializableError.builder() + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()); + return builder.build(); + } + } + + public static final class JavaCompilationFailedException extends RemoteException { + private JavaCompilationFailedSerializableError error; + + private int status; + + public JavaCompilationFailedException(JavaCompilationFailedSerializableError error, int status) { + super(error.toSerializableError(), status); + this.error = error; + this.status = status; + } + + public JavaCompilationFailedSerializableError error() { + return error; + } + } +} diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ConjureServerErrors.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ConjureServerErrors.java index ba840ccc2..d48ed3fd2 100644 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ConjureServerErrors.java +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ConjureServerErrors.java @@ -11,34 +11,35 @@ public final class ConjureServerErrors { private ConjureServerErrors() {} - public static ConflictingCauseSafeArg conflictingCauseSafeArg(@Safe String cause_, @Safe boolean shouldThrow_) { - return new ConflictingCauseSafeArg(cause_, shouldThrow_, null); + public static ConflictingCauseSafeArgErr conflictingCauseSafeArgErr( + @Safe String cause_, @Safe boolean shouldThrow_) { + return new ConflictingCauseSafeArgErr(cause_, shouldThrow_, null); } - public static ConflictingCauseSafeArg conflictingCauseSafeArg( + public static ConflictingCauseSafeArgErr conflictingCauseSafeArgErr( @Safe String cause_, @Safe boolean shouldThrow_, @Nullable Throwable cause) { - return new ConflictingCauseSafeArg(cause_, shouldThrow_, cause); + return new ConflictingCauseSafeArgErr(cause_, shouldThrow_, cause); } /** - * Throws a {@link ConflictingCauseSafeArg} when {@code shouldThrow} is true. + * Throws a {@link ConflictingCauseSafeArgErr} when {@code shouldThrow} is true. * * @param shouldThrow Cause the method to throw when true * @param cause_ * @param shouldThrow_ */ @Contract("true, _, _ -> fail") - public static void throwIfConflictingCauseSafeArg( + public static void throwIfConflictingCauseSafeArgErr( boolean shouldThrow, @Safe String cause_, @Safe boolean shouldThrow_) { if (shouldThrow) { - throw conflictingCauseSafeArg(cause_, shouldThrow_); + throw conflictingCauseSafeArgErr(cause_, shouldThrow_); } } - public static final class ConflictingCauseSafeArg extends EndpointServiceException { - private ConflictingCauseSafeArg(@Safe String cause_, @Safe boolean shouldThrow_, @Nullable Throwable cause) { + public static final class ConflictingCauseSafeArgErr extends EndpointServiceException { + private ConflictingCauseSafeArgErr(@Safe String cause_, @Safe boolean shouldThrow_, @Nullable Throwable cause) { super( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG, + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG_ERR, cause, SafeArg.of("cause", cause_), SafeArg.of("shouldThrow", shouldThrow_)); diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EmptyObject.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EmptyObject.java new file mode 100644 index 000000000..c2ba580b8 --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EmptyObject.java @@ -0,0 +1,28 @@ +package undertow.com.palantir.product; + +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.palantir.logsafe.Safe; +import javax.annotation.processing.Generated; + +@Safe +@JsonSerialize +@JsonIgnoreProperties(ignoreUnknown = true) +@Generated("com.palantir.conjure.java.types.BeanGenerator") +public final class EmptyObject { + private static final EmptyObject INSTANCE = new EmptyObject(); + + private EmptyObject() {} + + @Override + @Safe + public String toString() { + return "EmptyObject{}"; + } + + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + public static EmptyObject of() { + return INSTANCE; + } +} diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EmptyUnion.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EmptyUnion.java new file mode 100644 index 000000000..1f24db371 --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EmptyUnion.java @@ -0,0 +1,186 @@ +package undertow.com.palantir.product; + +import com.fasterxml.jackson.annotation.JsonAnyGetter; +import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonTypeInfo; +import com.fasterxml.jackson.annotation.JsonValue; +import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.Safe; +import com.palantir.logsafe.SafeArg; +import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; +import java.util.function.Function; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import javax.annotation.processing.Generated; + +@Generated("com.palantir.conjure.java.types.UnionGenerator") +public final class EmptyUnion { + private final Base value; + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + private EmptyUnion(Base value) { + this.value = value; + } + + @JsonValue + private Base getValue() { + return value; + } + + public static EmptyUnion unknown(@Safe String type, Object value) { + switch (Preconditions.checkNotNull(type, "Type is required")) { + default: + return new EmptyUnion(new UnknownWrapper(type, Collections.singletonMap(type, value))); + } + } + + public T accept(Visitor visitor) { + return value.accept(visitor); + } + + @Override + public boolean equals(@Nullable Object other) { + return this == other || (other instanceof EmptyUnion && equalTo((EmptyUnion) other)); + } + + private boolean equalTo(EmptyUnion other) { + return this.value.equals(other.value); + } + + @Override + public int hashCode() { + return this.value.hashCode(); + } + + @Override + public String toString() { + return "EmptyUnion{value: " + value + '}'; + } + + public interface Visitor { + T visitUnknown(@Safe String unknownType); + + static UnknownStageVisitorBuilder builder() { + return new VisitorBuilder(); + } + } + + private static final class VisitorBuilder + implements UnknownStageVisitorBuilder, Completed_StageVisitorBuilder { + private Function unknownVisitor; + + @Override + public Completed_StageVisitorBuilder unknown(@Nonnull Function unknownVisitor) { + Preconditions.checkNotNull(unknownVisitor, "unknownVisitor cannot be null"); + this.unknownVisitor = unknownVisitor; + return this; + } + + @Override + public Completed_StageVisitorBuilder throwOnUnknown() { + this.unknownVisitor = unknownType -> { + throw new SafeIllegalArgumentException( + "Unknown variant of the 'EmptyUnion' union", SafeArg.of("unknownType", unknownType)); + }; + return this; + } + + @Override + public Visitor build() { + final Function unknownVisitor = this.unknownVisitor; + return new Visitor() { + @Override + public T visitUnknown(String value) { + return unknownVisitor.apply(value); + } + }; + } + } + + public interface UnknownStageVisitorBuilder { + Completed_StageVisitorBuilder unknown(@Nonnull Function unknownVisitor); + + Completed_StageVisitorBuilder throwOnUnknown(); + } + + public interface Completed_StageVisitorBuilder { + Visitor build(); + } + + @JsonTypeInfo( + use = JsonTypeInfo.Id.NAME, + include = JsonTypeInfo.As.EXISTING_PROPERTY, + property = "type", + visible = true, + defaultImpl = UnknownWrapper.class) + @JsonIgnoreProperties(ignoreUnknown = true) + private interface Base { + T accept(Visitor visitor); + } + + private static final class UnknownWrapper implements Base { + private final String type; + + private final Map value; + + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + private UnknownWrapper(@JsonProperty("type") String type) { + this(type, new HashMap()); + } + + private UnknownWrapper(@Nonnull String type, @Nonnull Map value) { + Preconditions.checkNotNull(type, "type cannot be null"); + Preconditions.checkNotNull(value, "value cannot be null"); + this.type = type; + this.value = value; + } + + @JsonProperty + private String getType() { + return type; + } + + @JsonAnyGetter + private Map getValue() { + return value; + } + + @JsonAnySetter + private void put(String key, Object val) { + value.put(key, val); + } + + @Override + public T accept(Visitor visitor) { + return visitor.visitUnknown(type); + } + + @Override + public boolean equals(@Nullable Object other) { + return this == other || (other instanceof UnknownWrapper && equalTo((UnknownWrapper) other)); + } + + private boolean equalTo(UnknownWrapper other) { + return this.type.equals(other.type) && this.value.equals(other.value); + } + + @Override + public int hashCode() { + int hash = 1; + hash = 31 * hash + this.type.hashCode(); + hash = 31 * hash + this.value.hashCode(); + return hash; + } + + @Override + public String toString() { + return "UnknownWrapper{type: " + type + ", value: " + value + '}'; + } + } +} diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EnumExample.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EnumExample.java new file mode 100644 index 000000000..a7aed5d7f --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EnumExample.java @@ -0,0 +1,205 @@ +package undertow.com.palantir.product; + +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonValue; +import com.google.errorprone.annotations.Immutable; +import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.Safe; +import com.palantir.logsafe.SafeArg; +import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.Locale; +import java.util.function.Function; +import java.util.function.Supplier; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import javax.annotation.processing.Generated; + +/** + * This class is used instead of a native enum to support unknown values. Rather than throw an exception, the + * {@link EnumExample#valueOf} method defaults to a new instantiation of {@link EnumExample} where + * {@link EnumExample#get} will return {@link EnumExample.Value#UNKNOWN}. + * + *

For example, {@code EnumExample.valueOf("corrupted value").get()} will return {@link EnumExample.Value#UNKNOWN}, + * but {@link EnumExample#toString} will return "corrupted value". + * + *

There is no method to access all instantiations of this class, since they cannot be known at compile time. + */ +@Generated("com.palantir.conjure.java.types.EnumGenerator") +@Safe +@Immutable +public final class EnumExample { + public static final EnumExample A = new EnumExample(Value.A, "A"); + + public static final EnumExample B = new EnumExample(Value.B, "B"); + + private static final List values = Collections.unmodifiableList(Arrays.asList(A, B)); + + private final Value value; + + private final String string; + + private EnumExample(Value value, String string) { + this.value = value; + this.string = string; + } + + public Value get() { + return this.value; + } + + @Override + @JsonValue + public String toString() { + return this.string; + } + + @Override + public boolean equals(@Nullable Object other) { + return (this == other) + || (this.value == Value.UNKNOWN + && other instanceof EnumExample + && this.string.equals(((EnumExample) other).string)); + } + + @Override + public int hashCode() { + return this.string.hashCode(); + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static EnumExample valueOf(@Nonnull @Safe String value) { + Preconditions.checkNotNull(value, "value cannot be null"); + String upperCasedValue = value.toUpperCase(Locale.ROOT); + switch (upperCasedValue) { + case "A": + return A; + case "B": + return B; + default: + return new EnumExample(Value.UNKNOWN, upperCasedValue); + } + } + + public T accept(Visitor visitor) { + switch (value) { + case A: + return visitor.visitA(); + case B: + return visitor.visitB(); + default: + return visitor.visitUnknown(string); + } + } + + public static List values() { + return values; + } + + @Generated("com.palantir.conjure.java.types.EnumGenerator") + public enum Value { + A, + + B, + + UNKNOWN + } + + @Generated("com.palantir.conjure.java.types.EnumGenerator") + public interface Visitor { + T visitA(); + + T visitB(); + + T visitUnknown(String unknownValue); + + static AStageVisitorBuilder builder() { + return new VisitorBuilder(); + } + } + + private static final class VisitorBuilder + implements AStageVisitorBuilder, + BStageVisitorBuilder, + UnknownStageVisitorBuilder, + Completed_StageVisitorBuilder { + private Supplier aVisitor; + + private Supplier bVisitor; + + private Function<@Safe String, T> unknownVisitor; + + @Override + public BStageVisitorBuilder visitA(@Nonnull Supplier aVisitor) { + Preconditions.checkNotNull(aVisitor, "aVisitor cannot be null"); + this.aVisitor = aVisitor; + return this; + } + + @Override + public UnknownStageVisitorBuilder visitB(@Nonnull Supplier bVisitor) { + Preconditions.checkNotNull(bVisitor, "bVisitor cannot be null"); + this.bVisitor = bVisitor; + return this; + } + + @Override + public Completed_StageVisitorBuilder visitUnknown(@Nonnull Function<@Safe String, T> unknownVisitor) { + Preconditions.checkNotNull(unknownVisitor, "unknownVisitor cannot be null"); + this.unknownVisitor = unknownType -> unknownVisitor.apply(unknownType); + return this; + } + + @Override + public Completed_StageVisitorBuilder throwOnUnknown() { + this.unknownVisitor = unknownType -> { + throw new SafeIllegalArgumentException( + "Unknown variant of the 'EnumExample' union", SafeArg.of("unknownType", unknownType)); + }; + return this; + } + + @Override + public Visitor build() { + final Supplier aVisitor = this.aVisitor; + final Supplier bVisitor = this.bVisitor; + final Function<@Safe String, T> unknownVisitor = this.unknownVisitor; + return new Visitor() { + @Override + public T visitA() { + return aVisitor.get(); + } + + @Override + public T visitB() { + return bVisitor.get(); + } + + @Override + public T visitUnknown(String unknownType) { + return unknownVisitor.apply(unknownType); + } + }; + } + } + + public interface AStageVisitorBuilder { + BStageVisitorBuilder visitA(@Nonnull Supplier aVisitor); + } + + public interface BStageVisitorBuilder { + UnknownStageVisitorBuilder visitB(@Nonnull Supplier bVisitor); + } + + public interface UnknownStageVisitorBuilder { + Completed_StageVisitorBuilder visitUnknown(@Nonnull Function<@Safe String, T> unknownVisitor); + + Completed_StageVisitorBuilder throwOnUnknown(); + } + + public interface Completed_StageVisitorBuilder { + Visitor build(); + } +} diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ErrorServiceEndpoints.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ErrorServiceEndpoints.java index 07f135008..80b7b78be 100644 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ErrorServiceEndpoints.java +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ErrorServiceEndpoints.java @@ -60,7 +60,7 @@ private static final class TestBasicErrorEndpoint implements HttpHandler, Endpoi @Override public void handleRequest(HttpServerExchange exchange) - throws IOException, TestServerErrors.InvalidArgument, ConjureServerErrors.ConflictingCauseSafeArg { + throws IOException, TestServerErrors.InvalidArgument, ConjureServerErrors.ConflictingCauseSafeArgErr { AuthHeader authHeader = runtime.auth().header(exchange); Boolean shouldThrowError = deserializer.deserialize(exchange); String result = delegate.testBasicError(authHeader, shouldThrowError); diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ExternalExample.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ExternalExample.java new file mode 100644 index 000000000..fe87fe650 --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ExternalExample.java @@ -0,0 +1,185 @@ +package undertow.com.palantir.product; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonSetter; +import com.fasterxml.jackson.annotation.Nulls; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import com.google.errorprone.annotations.CheckReturnValue; +import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.SafeArg; +import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; +import java.util.function.Function; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import javax.annotation.processing.Generated; + +@JsonDeserialize(builder = ExternalExample.Builder.class) +@Generated("com.palantir.conjure.java.types.BeanGenerator") +public final class ExternalExample { + private final long externalLong; + + private final Optional optionalExternal; + + private int memoizedHashCode; + + private ExternalExample(long externalLong, Optional optionalExternal) { + validateFields(optionalExternal); + this.externalLong = externalLong; + this.optionalExternal = optionalExternal; + } + + @JsonProperty("externalLong") + public long getExternalLong() { + return this.externalLong; + } + + @JsonProperty("optionalExternal") + @JsonInclude(JsonInclude.Include.NON_ABSENT) + public Optional getOptionalExternal() { + return this.optionalExternal; + } + + @Override + public boolean equals(@Nullable Object other) { + return this == other || (other instanceof ExternalExample && equalTo((ExternalExample) other)); + } + + private boolean equalTo(ExternalExample other) { + if (this.memoizedHashCode != 0 + && other.memoizedHashCode != 0 + && this.memoizedHashCode != other.memoizedHashCode) { + return false; + } + return this.externalLong == other.externalLong && this.optionalExternal.equals(other.optionalExternal); + } + + @Override + public int hashCode() { + int result = memoizedHashCode; + if (result == 0) { + int hash = 1; + hash = 31 * hash + Long.hashCode(this.externalLong); + hash = 31 * hash + this.optionalExternal.hashCode(); + result = hash; + memoizedHashCode = result; + } + return result; + } + + @Override + public String toString() { + return "ExternalExample{externalLong: " + externalLong + ", optionalExternal: " + optionalExternal + '}'; + } + + public static ExternalExample of(long externalLong, long optionalExternal) { + return builder() + .externalLong(externalLong) + .optionalExternal(Optional.of(optionalExternal)) + .build(); + } + + private static void validateFields(Optional optionalExternal) { + List missingFields = null; + missingFields = addFieldIfMissing(missingFields, optionalExternal, "optionalExternal"); + if (missingFields != null) { + throw new SafeIllegalArgumentException( + "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); + } + } + + private static List addFieldIfMissing(List prev, Object fieldValue, String fieldName) { + List missingFields = prev; + if (fieldValue == null) { + if (missingFields == null) { + missingFields = new ArrayList<>(1); + } + missingFields.add(fieldName); + } + return missingFields; + } + + public static Builder builder() { + return new Builder(); + } + + @Generated("com.palantir.conjure.java.types.BeanBuilderGenerator") + @JsonIgnoreProperties(ignoreUnknown = true) + public static final class Builder { + boolean _buildInvoked; + + private long externalLong; + + private Optional optionalExternal = Optional.empty(); + + private boolean _externalLongInitialized = false; + + private Builder() {} + + public Builder from(ExternalExample other) { + checkNotBuilt(); + externalLong(other.getExternalLong()); + optionalExternal(other.getOptionalExternal()); + return this; + } + + @JsonSetter("externalLong") + public Builder externalLong(long externalLong) { + checkNotBuilt(); + this.externalLong = externalLong; + this._externalLongInitialized = true; + return this; + } + + @JsonSetter(value = "optionalExternal", nulls = Nulls.SKIP) + public Builder optionalExternal(@Nonnull Optional optionalExternal) { + checkNotBuilt(); + this.optionalExternal = Preconditions.checkNotNull(optionalExternal, "optionalExternal cannot be null") + .map(Function.identity()); + return this; + } + + public Builder optionalExternal(long optionalExternal) { + checkNotBuilt(); + this.optionalExternal = + Optional.of(Preconditions.checkNotNull(optionalExternal, "optionalExternal cannot be null")); + return this; + } + + private void validatePrimitiveFieldsHaveBeenInitialized() { + List missingFields = null; + missingFields = addFieldIfMissing(missingFields, _externalLongInitialized, "externalLong"); + if (missingFields != null) { + throw new SafeIllegalArgumentException( + "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); + } + } + + private static List addFieldIfMissing(List prev, boolean initialized, String fieldName) { + List missingFields = prev; + if (!initialized) { + if (missingFields == null) { + missingFields = new ArrayList<>(1); + } + missingFields.add(fieldName); + } + return missingFields; + } + + @CheckReturnValue + public ExternalExample build() { + checkNotBuilt(); + this._buildInvoked = true; + validatePrimitiveFieldsHaveBeenInitialized(); + return new ExternalExample(externalLong, optionalExternal); + } + + private void checkNotBuilt() { + Preconditions.checkState(!_buildInvoked, "Build has already been called"); + } + } +} diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/NestedAlias.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/NestedAlias.java new file mode 100644 index 000000000..c5ab4bb44 --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/NestedAlias.java @@ -0,0 +1,52 @@ +package undertow.com.palantir.product; + +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonValue; +import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.Safe; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import javax.annotation.processing.Generated; + +@Safe +@Generated("com.palantir.conjure.java.types.AliasGenerator") +public final class NestedAlias { + private final StringAliasEx value; + + private NestedAlias(@Nonnull StringAliasEx value) { + this.value = Preconditions.checkNotNull(value, "value cannot be null"); + } + + @JsonValue + public StringAliasEx get() { + return value; + } + + @Override + public String toString() { + return value.toString(); + } + + @Override + public boolean equals(@Nullable Object other) { + return this == other || (other instanceof NestedAlias && equalTo((NestedAlias) other)); + } + + private boolean equalTo(NestedAlias other) { + return this.value.equals(other.value); + } + + @Override + public int hashCode() { + return this.value.hashCode(); + } + + public static NestedAlias valueOf(@Safe String value) { + return of(StringAliasEx.valueOf(value)); + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static NestedAlias of(@Nonnull StringAliasEx value) { + return new NestedAlias(value); + } +} diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/NestedCollectionExample.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/NestedCollectionExample.java new file mode 100644 index 000000000..09e3c6ea3 --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/NestedCollectionExample.java @@ -0,0 +1,227 @@ +package undertow.com.palantir.product; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonSetter; +import com.fasterxml.jackson.annotation.Nulls; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import com.google.errorprone.annotations.CheckReturnValue; +import com.palantir.conjure.java.lib.internal.ConjureCollections; +import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.SafeArg; +import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; +import java.util.ArrayList; +import java.util.Collections; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import javax.annotation.processing.Generated; + +@JsonDeserialize(builder = NestedCollectionExample.Builder.class) +@Generated("com.palantir.conjure.java.types.BeanGenerator") +public final class NestedCollectionExample { + private final List> nestedList; + + private final Map> nestedMap; + + private final Map> mixedCollection; + + private int memoizedHashCode; + + private NestedCollectionExample( + List> nestedList, + Map> nestedMap, + Map> mixedCollection) { + validateFields(nestedList, nestedMap, mixedCollection); + this.nestedList = ConjureCollections.unmodifiableList(nestedList); + this.nestedMap = Collections.unmodifiableMap(nestedMap); + this.mixedCollection = Collections.unmodifiableMap(mixedCollection); + } + + @JsonProperty("nestedList") + public List> getNestedList() { + return this.nestedList; + } + + @JsonProperty("nestedMap") + public Map> getNestedMap() { + return this.nestedMap; + } + + @JsonProperty("mixedCollection") + public Map> getMixedCollection() { + return this.mixedCollection; + } + + @Override + public boolean equals(@Nullable Object other) { + return this == other || (other instanceof NestedCollectionExample && equalTo((NestedCollectionExample) other)); + } + + private boolean equalTo(NestedCollectionExample other) { + if (this.memoizedHashCode != 0 + && other.memoizedHashCode != 0 + && this.memoizedHashCode != other.memoizedHashCode) { + return false; + } + return this.nestedList.equals(other.nestedList) + && this.nestedMap.equals(other.nestedMap) + && this.mixedCollection.equals(other.mixedCollection); + } + + @Override + public int hashCode() { + int result = memoizedHashCode; + if (result == 0) { + int hash = 1; + hash = 31 * hash + this.nestedList.hashCode(); + hash = 31 * hash + this.nestedMap.hashCode(); + hash = 31 * hash + this.mixedCollection.hashCode(); + result = hash; + memoizedHashCode = result; + } + return result; + } + + @Override + public String toString() { + return "NestedCollectionExample{nestedList: " + nestedList + ", nestedMap: " + nestedMap + ", mixedCollection: " + + mixedCollection + '}'; + } + + public static NestedCollectionExample of( + List> nestedList, + Map> nestedMap, + Map> mixedCollection) { + return builder() + .nestedList(nestedList) + .nestedMap(nestedMap) + .mixedCollection(mixedCollection) + .build(); + } + + private static void validateFields( + List> nestedList, + Map> nestedMap, + Map> mixedCollection) { + List missingFields = null; + missingFields = addFieldIfMissing(missingFields, nestedList, "nestedList"); + missingFields = addFieldIfMissing(missingFields, nestedMap, "nestedMap"); + missingFields = addFieldIfMissing(missingFields, mixedCollection, "mixedCollection"); + if (missingFields != null) { + throw new SafeIllegalArgumentException( + "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); + } + } + + private static List addFieldIfMissing(List prev, Object fieldValue, String fieldName) { + List missingFields = prev; + if (fieldValue == null) { + if (missingFields == null) { + missingFields = new ArrayList<>(3); + } + missingFields.add(fieldName); + } + return missingFields; + } + + public static Builder builder() { + return new Builder(); + } + + @Generated("com.palantir.conjure.java.types.BeanBuilderGenerator") + @JsonIgnoreProperties(ignoreUnknown = true) + public static final class Builder { + boolean _buildInvoked; + + private List> nestedList = ConjureCollections.newNonNullList(); + + private Map> nestedMap = new LinkedHashMap<>(); + + private Map> mixedCollection = new LinkedHashMap<>(); + + private Builder() {} + + public Builder from(NestedCollectionExample other) { + checkNotBuilt(); + nestedList(other.getNestedList()); + nestedMap(other.getNestedMap()); + mixedCollection(other.getMixedCollection()); + return this; + } + + @JsonSetter(value = "nestedList", nulls = Nulls.SKIP, contentNulls = Nulls.FAIL) + public Builder nestedList(@Nonnull Iterable> nestedList) { + checkNotBuilt(); + this.nestedList = ConjureCollections.newNonNullList( + Preconditions.checkNotNull(nestedList, "nestedList cannot be null")); + return this; + } + + public Builder addAllNestedList(@Nonnull Iterable> nestedList) { + checkNotBuilt(); + ConjureCollections.addAllAndCheckNonNull( + this.nestedList, Preconditions.checkNotNull(nestedList, "nestedList cannot be null")); + return this; + } + + public Builder nestedList(List nestedList) { + checkNotBuilt(); + Preconditions.checkNotNull(nestedList, "nestedList cannot be null"); + this.nestedList.add(nestedList); + return this; + } + + @JsonSetter(value = "nestedMap", nulls = Nulls.SKIP, contentNulls = Nulls.FAIL) + public Builder nestedMap(@Nonnull Map> nestedMap) { + checkNotBuilt(); + this.nestedMap = new LinkedHashMap<>(Preconditions.checkNotNull(nestedMap, "nestedMap cannot be null")); + return this; + } + + public Builder putAllNestedMap(@Nonnull Map> nestedMap) { + checkNotBuilt(); + this.nestedMap.putAll(Preconditions.checkNotNull(nestedMap, "nestedMap cannot be null")); + return this; + } + + public Builder nestedMap(String key, Map value) { + checkNotBuilt(); + this.nestedMap.put(key, value); + return this; + } + + @JsonSetter(value = "mixedCollection", nulls = Nulls.SKIP, contentNulls = Nulls.FAIL) + public Builder mixedCollection(@Nonnull Map> mixedCollection) { + checkNotBuilt(); + this.mixedCollection = + new LinkedHashMap<>(Preconditions.checkNotNull(mixedCollection, "mixedCollection cannot be null")); + return this; + } + + public Builder putAllMixedCollection(@Nonnull Map> mixedCollection) { + checkNotBuilt(); + this.mixedCollection.putAll(Preconditions.checkNotNull(mixedCollection, "mixedCollection cannot be null")); + return this; + } + + public Builder mixedCollection(String key, List value) { + checkNotBuilt(); + this.mixedCollection.put(key, value); + return this; + } + + @CheckReturnValue + public NestedCollectionExample build() { + checkNotBuilt(); + this._buildInvoked = true; + return new NestedCollectionExample(nestedList, nestedMap, mixedCollection); + } + + private void checkNotBuilt() { + Preconditions.checkState(!_buildInvoked, "Build has already been called"); + } + } +} diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ObjectReference.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ObjectReference.java new file mode 100644 index 000000000..833a1d2fc --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ObjectReference.java @@ -0,0 +1,169 @@ +package undertow.com.palantir.product; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonSetter; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import com.google.errorprone.annotations.CheckReturnValue; +import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.SafeArg; +import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; +import java.util.ArrayList; +import java.util.List; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import javax.annotation.processing.Generated; + +@JsonDeserialize(builder = ObjectReference.Builder.class) +@Generated("com.palantir.conjure.java.types.BeanGenerator") +public final class ObjectReference { + private final String name; + + private final int value; + + private int memoizedHashCode; + + private ObjectReference(String name, int value) { + validateFields(name); + this.name = name; + this.value = value; + } + + @JsonProperty("name") + public String getName() { + return this.name; + } + + @JsonProperty("value") + public int getValue() { + return this.value; + } + + @Override + public boolean equals(@Nullable Object other) { + return this == other || (other instanceof ObjectReference && equalTo((ObjectReference) other)); + } + + private boolean equalTo(ObjectReference other) { + if (this.memoizedHashCode != 0 + && other.memoizedHashCode != 0 + && this.memoizedHashCode != other.memoizedHashCode) { + return false; + } + return this.name.equals(other.name) && this.value == other.value; + } + + @Override + public int hashCode() { + int result = memoizedHashCode; + if (result == 0) { + int hash = 1; + hash = 31 * hash + this.name.hashCode(); + hash = 31 * hash + this.value; + result = hash; + memoizedHashCode = result; + } + return result; + } + + @Override + public String toString() { + return "ObjectReference{name: " + name + ", value: " + value + '}'; + } + + public static ObjectReference of(String name, int value) { + return builder().name(name).value(value).build(); + } + + private static void validateFields(String name) { + List missingFields = null; + missingFields = addFieldIfMissing(missingFields, name, "name"); + if (missingFields != null) { + throw new SafeIllegalArgumentException( + "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); + } + } + + private static List addFieldIfMissing(List prev, Object fieldValue, String fieldName) { + List missingFields = prev; + if (fieldValue == null) { + if (missingFields == null) { + missingFields = new ArrayList<>(1); + } + missingFields.add(fieldName); + } + return missingFields; + } + + public static Builder builder() { + return new Builder(); + } + + @Generated("com.palantir.conjure.java.types.BeanBuilderGenerator") + @JsonIgnoreProperties(ignoreUnknown = true) + public static final class Builder { + boolean _buildInvoked; + + private String name; + + private int value; + + private boolean _valueInitialized = false; + + private Builder() {} + + public Builder from(ObjectReference other) { + checkNotBuilt(); + name(other.getName()); + value(other.getValue()); + return this; + } + + @JsonSetter("name") + public Builder name(@Nonnull String name) { + checkNotBuilt(); + this.name = Preconditions.checkNotNull(name, "name cannot be null"); + return this; + } + + @JsonSetter("value") + public Builder value(int value) { + checkNotBuilt(); + this.value = value; + this._valueInitialized = true; + return this; + } + + private void validatePrimitiveFieldsHaveBeenInitialized() { + List missingFields = null; + missingFields = addFieldIfMissing(missingFields, _valueInitialized, "value"); + if (missingFields != null) { + throw new SafeIllegalArgumentException( + "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); + } + } + + private static List addFieldIfMissing(List prev, boolean initialized, String fieldName) { + List missingFields = prev; + if (!initialized) { + if (missingFields == null) { + missingFields = new ArrayList<>(1); + } + missingFields.add(fieldName); + } + return missingFields; + } + + @CheckReturnValue + public ObjectReference build() { + checkNotBuilt(); + this._buildInvoked = true; + validatePrimitiveFieldsHaveBeenInitialized(); + return new ObjectReference(name, value); + } + + private void checkNotBuilt() { + Preconditions.checkState(!_buildInvoked, "Build has already been called"); + } + } +} diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/OptionalAlias.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/OptionalAlias.java new file mode 100644 index 000000000..50a669fe1 --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/OptionalAlias.java @@ -0,0 +1,60 @@ +package undertow.com.palantir.product; + +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonValue; +import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.Safe; +import java.util.Optional; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import javax.annotation.processing.Generated; + +@Safe +@Generated("com.palantir.conjure.java.types.AliasGenerator") +public final class OptionalAlias { + private static final OptionalAlias EMPTY = new OptionalAlias(); + + private final Optional<@Safe String> value; + + private OptionalAlias(@Nonnull Optional<@Safe String> value) { + this.value = Preconditions.checkNotNull(value, "value cannot be null"); + } + + private OptionalAlias() { + this(Optional.empty()); + } + + @JsonValue + public Optional<@Safe String> get() { + return value; + } + + @Override + @Safe + public String toString() { + return value.toString(); + } + + @Override + public boolean equals(@Nullable Object other) { + return this == other || (other instanceof OptionalAlias && equalTo((OptionalAlias) other)); + } + + private boolean equalTo(OptionalAlias other) { + return this.value.equals(other.value); + } + + @Override + public int hashCode() { + return this.value.hashCode(); + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static OptionalAlias of(@Nonnull Optional<@Safe String> value) { + return new OptionalAlias(value); + } + + public static OptionalAlias empty() { + return EMPTY; + } +} diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/OptionalExample.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/OptionalExample.java new file mode 100644 index 000000000..351a51d7d --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/OptionalExample.java @@ -0,0 +1,210 @@ +package undertow.com.palantir.product; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonSetter; +import com.fasterxml.jackson.annotation.Nulls; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import com.google.errorprone.annotations.CheckReturnValue; +import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.SafeArg; +import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; +import java.util.function.Function; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import javax.annotation.processing.Generated; + +@JsonDeserialize(builder = OptionalExample.Builder.class) +@Generated("com.palantir.conjure.java.types.BeanGenerator") +public final class OptionalExample { + private final Optional optionalString; + + private final Optional optionalObject; + + private final Optional> optionalCollection; + + private int memoizedHashCode; + + private OptionalExample( + Optional optionalString, + Optional optionalObject, + Optional> optionalCollection) { + validateFields(optionalString, optionalObject, optionalCollection); + this.optionalString = optionalString; + this.optionalObject = optionalObject; + this.optionalCollection = optionalCollection; + } + + @JsonProperty("optionalString") + @JsonInclude(JsonInclude.Include.NON_ABSENT) + public Optional getOptionalString() { + return this.optionalString; + } + + @JsonProperty("optionalObject") + @JsonInclude(JsonInclude.Include.NON_ABSENT) + public Optional getOptionalObject() { + return this.optionalObject; + } + + @JsonProperty("optionalCollection") + @JsonInclude(JsonInclude.Include.NON_ABSENT) + public Optional> getOptionalCollection() { + return this.optionalCollection; + } + + @Override + public boolean equals(@Nullable Object other) { + return this == other || (other instanceof OptionalExample && equalTo((OptionalExample) other)); + } + + private boolean equalTo(OptionalExample other) { + if (this.memoizedHashCode != 0 + && other.memoizedHashCode != 0 + && this.memoizedHashCode != other.memoizedHashCode) { + return false; + } + return this.optionalString.equals(other.optionalString) + && this.optionalObject.equals(other.optionalObject) + && this.optionalCollection.equals(other.optionalCollection); + } + + @Override + public int hashCode() { + int result = memoizedHashCode; + if (result == 0) { + int hash = 1; + hash = 31 * hash + this.optionalString.hashCode(); + hash = 31 * hash + this.optionalObject.hashCode(); + hash = 31 * hash + this.optionalCollection.hashCode(); + result = hash; + memoizedHashCode = result; + } + return result; + } + + @Override + public String toString() { + return "OptionalExample{optionalString: " + optionalString + ", optionalObject: " + optionalObject + + ", optionalCollection: " + optionalCollection + '}'; + } + + public static OptionalExample of( + String optionalString, ObjectReference optionalObject, List optionalCollection) { + return builder() + .optionalString(Optional.of(optionalString)) + .optionalObject(Optional.of(optionalObject)) + .optionalCollection(Optional.of(optionalCollection)) + .build(); + } + + private static void validateFields( + Optional optionalString, + Optional optionalObject, + Optional> optionalCollection) { + List missingFields = null; + missingFields = addFieldIfMissing(missingFields, optionalString, "optionalString"); + missingFields = addFieldIfMissing(missingFields, optionalObject, "optionalObject"); + missingFields = addFieldIfMissing(missingFields, optionalCollection, "optionalCollection"); + if (missingFields != null) { + throw new SafeIllegalArgumentException( + "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); + } + } + + private static List addFieldIfMissing(List prev, Object fieldValue, String fieldName) { + List missingFields = prev; + if (fieldValue == null) { + if (missingFields == null) { + missingFields = new ArrayList<>(3); + } + missingFields.add(fieldName); + } + return missingFields; + } + + public static Builder builder() { + return new Builder(); + } + + @Generated("com.palantir.conjure.java.types.BeanBuilderGenerator") + @JsonIgnoreProperties(ignoreUnknown = true) + public static final class Builder { + boolean _buildInvoked; + + private Optional optionalString = Optional.empty(); + + private Optional optionalObject = Optional.empty(); + + private Optional> optionalCollection = Optional.empty(); + + private Builder() {} + + public Builder from(OptionalExample other) { + checkNotBuilt(); + optionalString(other.getOptionalString()); + optionalObject(other.getOptionalObject()); + optionalCollection(other.getOptionalCollection()); + return this; + } + + @JsonSetter(value = "optionalString", nulls = Nulls.SKIP) + public Builder optionalString(@Nonnull Optional optionalString) { + checkNotBuilt(); + this.optionalString = Preconditions.checkNotNull(optionalString, "optionalString cannot be null"); + return this; + } + + public Builder optionalString(@Nonnull String optionalString) { + checkNotBuilt(); + this.optionalString = + Optional.of(Preconditions.checkNotNull(optionalString, "optionalString cannot be null")); + return this; + } + + @JsonSetter(value = "optionalObject", nulls = Nulls.SKIP) + public Builder optionalObject(@Nonnull Optional optionalObject) { + checkNotBuilt(); + this.optionalObject = Preconditions.checkNotNull(optionalObject, "optionalObject cannot be null"); + return this; + } + + public Builder optionalObject(@Nonnull ObjectReference optionalObject) { + checkNotBuilt(); + this.optionalObject = + Optional.of(Preconditions.checkNotNull(optionalObject, "optionalObject cannot be null")); + return this; + } + + @JsonSetter(value = "optionalCollection", nulls = Nulls.SKIP) + public Builder optionalCollection(@Nonnull Optional> optionalCollection) { + checkNotBuilt(); + this.optionalCollection = Preconditions.checkNotNull( + optionalCollection, "optionalCollection cannot be null") + .map(Function.identity()); + return this; + } + + public Builder optionalCollection(@Nonnull List optionalCollection) { + checkNotBuilt(); + this.optionalCollection = + Optional.of(Preconditions.checkNotNull(optionalCollection, "optionalCollection cannot be null")); + return this; + } + + @CheckReturnValue + public OptionalExample build() { + checkNotBuilt(); + this._buildInvoked = true; + return new OptionalExample(optionalString, optionalObject, optionalCollection); + } + + private void checkNotBuilt() { + Preconditions.checkState(!_buildInvoked, "Build has already been called"); + } + } +} diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/PrimitiveExample.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/PrimitiveExample.java new file mode 100644 index 000000000..290fa3728 --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/PrimitiveExample.java @@ -0,0 +1,345 @@ +package undertow.com.palantir.product; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonSetter; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import com.google.errorprone.annotations.CheckReturnValue; +import com.palantir.conjure.java.lib.SafeLong; +import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.SafeArg; +import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; +import com.palantir.ri.ResourceIdentifier; +import java.nio.Buffer; +import java.nio.ByteBuffer; +import java.time.OffsetDateTime; +import java.util.ArrayList; +import java.util.List; +import java.util.UUID; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import javax.annotation.processing.Generated; + +@JsonDeserialize(builder = PrimitiveExample.Builder.class) +@Generated("com.palantir.conjure.java.types.BeanGenerator") +public final class PrimitiveExample { + private final String stringVal; + + private final int intVal; + + private final SafeLong longVal; + + private final double doubleVal; + + private final boolean boolVal; + + private final ResourceIdentifier ridVal; + + private final UUID uuidVal; + + private final OffsetDateTime datetimeVal; + + private final ByteBuffer binaryVal; + + private int memoizedHashCode; + + private PrimitiveExample( + String stringVal, + int intVal, + SafeLong longVal, + double doubleVal, + boolean boolVal, + ResourceIdentifier ridVal, + UUID uuidVal, + OffsetDateTime datetimeVal, + ByteBuffer binaryVal) { + validateFields(stringVal, longVal, ridVal, uuidVal, datetimeVal, binaryVal); + this.stringVal = stringVal; + this.intVal = intVal; + this.longVal = longVal; + this.doubleVal = doubleVal; + this.boolVal = boolVal; + this.ridVal = ridVal; + this.uuidVal = uuidVal; + this.datetimeVal = datetimeVal; + this.binaryVal = binaryVal; + } + + @JsonProperty("stringVal") + public String getStringVal() { + return this.stringVal; + } + + @JsonProperty("intVal") + public int getIntVal() { + return this.intVal; + } + + @JsonProperty("longVal") + public SafeLong getLongVal() { + return this.longVal; + } + + @JsonProperty("doubleVal") + public double getDoubleVal() { + return this.doubleVal; + } + + @JsonProperty("boolVal") + public boolean getBoolVal() { + return this.boolVal; + } + + @JsonProperty("ridVal") + public ResourceIdentifier getRidVal() { + return this.ridVal; + } + + @JsonProperty("uuidVal") + public UUID getUuidVal() { + return this.uuidVal; + } + + @JsonProperty("datetimeVal") + public OffsetDateTime getDatetimeVal() { + return this.datetimeVal; + } + + @JsonProperty("binaryVal") + public ByteBuffer getBinaryVal() { + return this.binaryVal.asReadOnlyBuffer(); + } + + @Override + public boolean equals(@Nullable Object other) { + return this == other || (other instanceof PrimitiveExample && equalTo((PrimitiveExample) other)); + } + + private boolean equalTo(PrimitiveExample other) { + if (this.memoizedHashCode != 0 + && other.memoizedHashCode != 0 + && this.memoizedHashCode != other.memoizedHashCode) { + return false; + } + return this.stringVal.equals(other.stringVal) + && this.intVal == other.intVal + && this.longVal.equals(other.longVal) + && Double.doubleToLongBits(this.doubleVal) == Double.doubleToLongBits(other.doubleVal) + && this.boolVal == other.boolVal + && this.ridVal.equals(other.ridVal) + && this.uuidVal.equals(other.uuidVal) + && this.datetimeVal.isEqual(other.datetimeVal) + && this.binaryVal.equals(other.binaryVal); + } + + @Override + public int hashCode() { + int result = memoizedHashCode; + if (result == 0) { + int hash = 1; + hash = 31 * hash + this.stringVal.hashCode(); + hash = 31 * hash + this.intVal; + hash = 31 * hash + this.longVal.hashCode(); + hash = 31 * hash + Double.hashCode(this.doubleVal); + hash = 31 * hash + Boolean.hashCode(this.boolVal); + hash = 31 * hash + this.ridVal.hashCode(); + hash = 31 * hash + this.uuidVal.hashCode(); + hash = 31 * hash + this.datetimeVal.toInstant().hashCode(); + hash = 31 * hash + this.binaryVal.hashCode(); + result = hash; + memoizedHashCode = result; + } + return result; + } + + @Override + public String toString() { + return "PrimitiveExample{stringVal: " + stringVal + ", intVal: " + intVal + ", longVal: " + longVal + + ", doubleVal: " + doubleVal + ", boolVal: " + boolVal + ", ridVal: " + ridVal + ", uuidVal: " + + uuidVal + ", datetimeVal: " + datetimeVal + ", binaryVal: " + binaryVal + '}'; + } + + private static void validateFields( + String stringVal, + SafeLong longVal, + ResourceIdentifier ridVal, + UUID uuidVal, + OffsetDateTime datetimeVal, + ByteBuffer binaryVal) { + List missingFields = null; + missingFields = addFieldIfMissing(missingFields, stringVal, "stringVal"); + missingFields = addFieldIfMissing(missingFields, longVal, "longVal"); + missingFields = addFieldIfMissing(missingFields, ridVal, "ridVal"); + missingFields = addFieldIfMissing(missingFields, uuidVal, "uuidVal"); + missingFields = addFieldIfMissing(missingFields, datetimeVal, "datetimeVal"); + missingFields = addFieldIfMissing(missingFields, binaryVal, "binaryVal"); + if (missingFields != null) { + throw new SafeIllegalArgumentException( + "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); + } + } + + private static List addFieldIfMissing(List prev, Object fieldValue, String fieldName) { + List missingFields = prev; + if (fieldValue == null) { + if (missingFields == null) { + missingFields = new ArrayList<>(6); + } + missingFields.add(fieldName); + } + return missingFields; + } + + public static Builder builder() { + return new Builder(); + } + + @Generated("com.palantir.conjure.java.types.BeanBuilderGenerator") + @JsonIgnoreProperties(ignoreUnknown = true) + public static final class Builder { + boolean _buildInvoked; + + private String stringVal; + + private int intVal; + + private SafeLong longVal; + + private double doubleVal; + + private boolean boolVal; + + private ResourceIdentifier ridVal; + + private UUID uuidVal; + + private OffsetDateTime datetimeVal; + + private ByteBuffer binaryVal; + + private boolean _intValInitialized = false; + + private boolean _doubleValInitialized = false; + + private boolean _boolValInitialized = false; + + private Builder() {} + + public Builder from(PrimitiveExample other) { + checkNotBuilt(); + stringVal(other.getStringVal()); + intVal(other.getIntVal()); + longVal(other.getLongVal()); + doubleVal(other.getDoubleVal()); + boolVal(other.getBoolVal()); + ridVal(other.getRidVal()); + uuidVal(other.getUuidVal()); + datetimeVal(other.getDatetimeVal()); + binaryVal(other.getBinaryVal()); + return this; + } + + @JsonSetter("stringVal") + public Builder stringVal(@Nonnull String stringVal) { + checkNotBuilt(); + this.stringVal = Preconditions.checkNotNull(stringVal, "stringVal cannot be null"); + return this; + } + + @JsonSetter("intVal") + public Builder intVal(int intVal) { + checkNotBuilt(); + this.intVal = intVal; + this._intValInitialized = true; + return this; + } + + @JsonSetter("longVal") + public Builder longVal(@Nonnull SafeLong longVal) { + checkNotBuilt(); + this.longVal = Preconditions.checkNotNull(longVal, "longVal cannot be null"); + return this; + } + + @JsonSetter("doubleVal") + public Builder doubleVal(double doubleVal) { + checkNotBuilt(); + this.doubleVal = doubleVal; + this._doubleValInitialized = true; + return this; + } + + @JsonSetter("boolVal") + public Builder boolVal(boolean boolVal) { + checkNotBuilt(); + this.boolVal = boolVal; + this._boolValInitialized = true; + return this; + } + + @JsonSetter("ridVal") + public Builder ridVal(@Nonnull ResourceIdentifier ridVal) { + checkNotBuilt(); + this.ridVal = Preconditions.checkNotNull(ridVal, "ridVal cannot be null"); + return this; + } + + @JsonSetter("uuidVal") + public Builder uuidVal(@Nonnull UUID uuidVal) { + checkNotBuilt(); + this.uuidVal = Preconditions.checkNotNull(uuidVal, "uuidVal cannot be null"); + return this; + } + + @JsonSetter("datetimeVal") + public Builder datetimeVal(@Nonnull OffsetDateTime datetimeVal) { + checkNotBuilt(); + this.datetimeVal = Preconditions.checkNotNull(datetimeVal, "datetimeVal cannot be null"); + return this; + } + + @JsonSetter("binaryVal") + public Builder binaryVal(@Nonnull ByteBuffer binaryVal) { + checkNotBuilt(); + Preconditions.checkNotNull(binaryVal, "binaryVal cannot be null"); + this.binaryVal = ByteBuffer.allocate(binaryVal.remaining()).put(binaryVal.duplicate()); + ((Buffer) this.binaryVal).rewind(); + return this; + } + + private void validatePrimitiveFieldsHaveBeenInitialized() { + List missingFields = null; + missingFields = addFieldIfMissing(missingFields, _intValInitialized, "intVal"); + missingFields = addFieldIfMissing(missingFields, _doubleValInitialized, "doubleVal"); + missingFields = addFieldIfMissing(missingFields, _boolValInitialized, "boolVal"); + if (missingFields != null) { + throw new SafeIllegalArgumentException( + "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); + } + } + + private static List addFieldIfMissing(List prev, boolean initialized, String fieldName) { + List missingFields = prev; + if (!initialized) { + if (missingFields == null) { + missingFields = new ArrayList<>(3); + } + missingFields.add(fieldName); + } + return missingFields; + } + + @CheckReturnValue + public PrimitiveExample build() { + checkNotBuilt(); + this._buildInvoked = true; + validatePrimitiveFieldsHaveBeenInitialized(); + return new PrimitiveExample( + stringVal, intVal, longVal, doubleVal, boolVal, ridVal, uuidVal, datetimeVal, binaryVal); + } + + private void checkNotBuilt() { + Preconditions.checkState(!_buildInvoked, "Build has already been called"); + } + } +} diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/SafetyExample.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/SafetyExample.java new file mode 100644 index 000000000..08998d310 --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/SafetyExample.java @@ -0,0 +1,176 @@ +package undertow.com.palantir.product; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonSetter; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import com.google.errorprone.annotations.CheckReturnValue; +import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.Safe; +import com.palantir.logsafe.SafeArg; +import com.palantir.logsafe.Unsafe; +import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; +import java.util.ArrayList; +import java.util.List; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import javax.annotation.processing.Generated; + +@Unsafe +@JsonDeserialize(builder = SafetyExample.Builder.class) +@Generated("com.palantir.conjure.java.types.BeanGenerator") +public final class SafetyExample { + private final String safeString; + + private final double unsafeDouble; + + private int memoizedHashCode; + + private SafetyExample(String safeString, double unsafeDouble) { + validateFields(safeString); + this.safeString = safeString; + this.unsafeDouble = unsafeDouble; + } + + @JsonProperty("safeString") + @Safe + public String getSafeString() { + return this.safeString; + } + + @JsonProperty("unsafeDouble") + @Unsafe + public double getUnsafeDouble() { + return this.unsafeDouble; + } + + @Override + public boolean equals(@Nullable Object other) { + return this == other || (other instanceof SafetyExample && equalTo((SafetyExample) other)); + } + + private boolean equalTo(SafetyExample other) { + if (this.memoizedHashCode != 0 + && other.memoizedHashCode != 0 + && this.memoizedHashCode != other.memoizedHashCode) { + return false; + } + return this.safeString.equals(other.safeString) + && Double.doubleToLongBits(this.unsafeDouble) == Double.doubleToLongBits(other.unsafeDouble); + } + + @Override + public int hashCode() { + int result = memoizedHashCode; + if (result == 0) { + int hash = 1; + hash = 31 * hash + this.safeString.hashCode(); + hash = 31 * hash + Double.hashCode(this.unsafeDouble); + result = hash; + memoizedHashCode = result; + } + return result; + } + + @Override + @Unsafe + public String toString() { + return "SafetyExample{safeString: " + safeString + ", unsafeDouble: " + unsafeDouble + '}'; + } + + public static SafetyExample of(@Safe String safeString, @Unsafe double unsafeDouble) { + return builder().safeString(safeString).unsafeDouble(unsafeDouble).build(); + } + + private static void validateFields(String safeString) { + List missingFields = null; + missingFields = addFieldIfMissing(missingFields, safeString, "safeString"); + if (missingFields != null) { + throw new SafeIllegalArgumentException( + "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); + } + } + + private static List addFieldIfMissing(List prev, Object fieldValue, String fieldName) { + List missingFields = prev; + if (fieldValue == null) { + if (missingFields == null) { + missingFields = new ArrayList<>(1); + } + missingFields.add(fieldName); + } + return missingFields; + } + + public static Builder builder() { + return new Builder(); + } + + @Generated("com.palantir.conjure.java.types.BeanBuilderGenerator") + @JsonIgnoreProperties(ignoreUnknown = true) + public static final class Builder { + boolean _buildInvoked; + + private @Safe String safeString; + + private @Unsafe double unsafeDouble; + + private boolean _unsafeDoubleInitialized = false; + + private Builder() {} + + public Builder from(SafetyExample other) { + checkNotBuilt(); + safeString(other.getSafeString()); + unsafeDouble(other.getUnsafeDouble()); + return this; + } + + @JsonSetter("safeString") + public Builder safeString(@Nonnull @Safe String safeString) { + checkNotBuilt(); + this.safeString = Preconditions.checkNotNull(safeString, "safeString cannot be null"); + return this; + } + + @JsonSetter("unsafeDouble") + public Builder unsafeDouble(@Unsafe double unsafeDouble) { + checkNotBuilt(); + this.unsafeDouble = unsafeDouble; + this._unsafeDoubleInitialized = true; + return this; + } + + private void validatePrimitiveFieldsHaveBeenInitialized() { + List missingFields = null; + missingFields = addFieldIfMissing(missingFields, _unsafeDoubleInitialized, "unsafeDouble"); + if (missingFields != null) { + throw new SafeIllegalArgumentException( + "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); + } + } + + private static List addFieldIfMissing(List prev, boolean initialized, String fieldName) { + List missingFields = prev; + if (!initialized) { + if (missingFields == null) { + missingFields = new ArrayList<>(1); + } + missingFields.add(fieldName); + } + return missingFields; + } + + @CheckReturnValue + public SafetyExample build() { + checkNotBuilt(); + this._buildInvoked = true; + validatePrimitiveFieldsHaveBeenInitialized(); + return new SafetyExample(safeString, unsafeDouble); + } + + private void checkNotBuilt() { + Preconditions.checkState(!_buildInvoked, "Build has already been called"); + } + } +} diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/StringAliasEx.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/StringAliasEx.java new file mode 100644 index 000000000..2c1c6645e --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/StringAliasEx.java @@ -0,0 +1,58 @@ +package undertow.com.palantir.product; + +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonValue; +import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.Safe; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import javax.annotation.processing.Generated; + +@Safe +@Generated("com.palantir.conjure.java.types.AliasGenerator") +public final class StringAliasEx implements Comparable { + private final @Safe String value; + + private StringAliasEx(@Nonnull @Safe String value) { + this.value = Preconditions.checkNotNull(value, "value cannot be null"); + } + + @JsonValue + public @Safe String get() { + return value; + } + + @Override + @Safe + public String toString() { + return value.toString(); + } + + @Override + public boolean equals(@Nullable Object other) { + return this == other || (other instanceof StringAliasEx && equalTo((StringAliasEx) other)); + } + + private boolean equalTo(StringAliasEx other) { + return this.value.equals(other.value); + } + + @Override + public int hashCode() { + return this.value.hashCode(); + } + + @Override + public int compareTo(StringAliasEx other) { + return value.compareTo(other.get()); + } + + public static StringAliasEx valueOf(@Safe String value) { + return of(value); + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static StringAliasEx of(@Nonnull @Safe String value) { + return new StringAliasEx(value); + } +} diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/UndertowErrorService.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/UndertowErrorService.java index 124d41207..2dc96cadc 100644 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/UndertowErrorService.java +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/UndertowErrorService.java @@ -10,10 +10,10 @@ public interface UndertowErrorService { /** * @apiNote {@code POST /errors/basic} * @throws TestServerErrors.InvalidArgument - * @throws ConjureServerErrors.ConflictingCauseSafeArg + * @throws ConjureServerErrors.ConflictingCauseSafeArgErr */ String testBasicError(AuthHeader authHeader, boolean shouldThrowError) - throws TestServerErrors.InvalidArgument, ConjureServerErrors.ConflictingCauseSafeArg; + throws TestServerErrors.InvalidArgument, ConjureServerErrors.ConflictingCauseSafeArgErr; /** * @apiNote {@code POST /errors/imported} diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/UnionExample.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/UnionExample.java new file mode 100644 index 000000000..4892a4eca --- /dev/null +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/UnionExample.java @@ -0,0 +1,579 @@ +package undertow.com.palantir.product; + +import com.fasterxml.jackson.annotation.JsonAnyGetter; +import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonSetter; +import com.fasterxml.jackson.annotation.JsonSubTypes; +import com.fasterxml.jackson.annotation.JsonTypeInfo; +import com.fasterxml.jackson.annotation.JsonTypeName; +import com.fasterxml.jackson.annotation.JsonValue; +import com.fasterxml.jackson.annotation.Nulls; +import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.Safe; +import com.palantir.logsafe.SafeArg; +import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.function.Function; +import java.util.function.IntFunction; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import javax.annotation.processing.Generated; + +@Generated("com.palantir.conjure.java.types.UnionGenerator") +public final class UnionExample { + private final Base value; + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + private UnionExample(Base value) { + this.value = value; + } + + @JsonValue + private Base getValue() { + return value; + } + + public static UnionExample stringVariant(String value) { + return new UnionExample(new StringVariantWrapper(value)); + } + + public static UnionExample intVariant(int value) { + return new UnionExample(new IntVariantWrapper(value)); + } + + public static UnionExample objectVariant(ObjectReference value) { + return new UnionExample(new ObjectVariantWrapper(value)); + } + + public static UnionExample collectionVariant(List value) { + return new UnionExample(new CollectionVariantWrapper(value)); + } + + public static UnionExample optionalVariant(Optional value) { + return new UnionExample(new OptionalVariantWrapper(value)); + } + + public static UnionExample unknown(@Safe String type, Object value) { + switch (Preconditions.checkNotNull(type, "Type is required")) { + case "stringVariant": + throw new SafeIllegalArgumentException( + "Unknown type cannot be created as the provided type is known: stringVariant"); + case "intVariant": + throw new SafeIllegalArgumentException( + "Unknown type cannot be created as the provided type is known: intVariant"); + case "objectVariant": + throw new SafeIllegalArgumentException( + "Unknown type cannot be created as the provided type is known: objectVariant"); + case "collectionVariant": + throw new SafeIllegalArgumentException( + "Unknown type cannot be created as the provided type is known: collectionVariant"); + case "optionalVariant": + throw new SafeIllegalArgumentException( + "Unknown type cannot be created as the provided type is known: optionalVariant"); + default: + return new UnionExample(new UnknownWrapper(type, Collections.singletonMap(type, value))); + } + } + + public T accept(Visitor visitor) { + return value.accept(visitor); + } + + @Override + public boolean equals(@Nullable Object other) { + return this == other || (other instanceof UnionExample && equalTo((UnionExample) other)); + } + + private boolean equalTo(UnionExample other) { + return this.value.equals(other.value); + } + + @Override + public int hashCode() { + return this.value.hashCode(); + } + + @Override + public String toString() { + return "UnionExample{value: " + value + '}'; + } + + public interface Visitor { + T visitStringVariant(String value); + + T visitIntVariant(int value); + + T visitObjectVariant(ObjectReference value); + + T visitCollectionVariant(List value); + + T visitOptionalVariant(Optional value); + + T visitUnknown(@Safe String unknownType); + + static CollectionVariantStageVisitorBuilder builder() { + return new VisitorBuilder(); + } + } + + private static final class VisitorBuilder + implements CollectionVariantStageVisitorBuilder, + IntVariantStageVisitorBuilder, + ObjectVariantStageVisitorBuilder, + OptionalVariantStageVisitorBuilder, + StringVariantStageVisitorBuilder, + UnknownStageVisitorBuilder, + Completed_StageVisitorBuilder { + private Function, T> collectionVariantVisitor; + + private IntFunction intVariantVisitor; + + private Function objectVariantVisitor; + + private Function, T> optionalVariantVisitor; + + private Function stringVariantVisitor; + + private Function unknownVisitor; + + @Override + public IntVariantStageVisitorBuilder collectionVariant( + @Nonnull Function, T> collectionVariantVisitor) { + Preconditions.checkNotNull(collectionVariantVisitor, "collectionVariantVisitor cannot be null"); + this.collectionVariantVisitor = collectionVariantVisitor; + return this; + } + + @Override + public ObjectVariantStageVisitorBuilder intVariant(@Nonnull IntFunction intVariantVisitor) { + Preconditions.checkNotNull(intVariantVisitor, "intVariantVisitor cannot be null"); + this.intVariantVisitor = intVariantVisitor; + return this; + } + + @Override + public OptionalVariantStageVisitorBuilder objectVariant( + @Nonnull Function objectVariantVisitor) { + Preconditions.checkNotNull(objectVariantVisitor, "objectVariantVisitor cannot be null"); + this.objectVariantVisitor = objectVariantVisitor; + return this; + } + + @Override + public StringVariantStageVisitorBuilder optionalVariant( + @Nonnull Function, T> optionalVariantVisitor) { + Preconditions.checkNotNull(optionalVariantVisitor, "optionalVariantVisitor cannot be null"); + this.optionalVariantVisitor = optionalVariantVisitor; + return this; + } + + @Override + public UnknownStageVisitorBuilder stringVariant(@Nonnull Function stringVariantVisitor) { + Preconditions.checkNotNull(stringVariantVisitor, "stringVariantVisitor cannot be null"); + this.stringVariantVisitor = stringVariantVisitor; + return this; + } + + @Override + public Completed_StageVisitorBuilder unknown(@Nonnull Function unknownVisitor) { + Preconditions.checkNotNull(unknownVisitor, "unknownVisitor cannot be null"); + this.unknownVisitor = unknownVisitor; + return this; + } + + @Override + public Completed_StageVisitorBuilder throwOnUnknown() { + this.unknownVisitor = unknownType -> { + throw new SafeIllegalArgumentException( + "Unknown variant of the 'UnionExample' union", SafeArg.of("unknownType", unknownType)); + }; + return this; + } + + @Override + public Visitor build() { + final Function, T> collectionVariantVisitor = this.collectionVariantVisitor; + final IntFunction intVariantVisitor = this.intVariantVisitor; + final Function objectVariantVisitor = this.objectVariantVisitor; + final Function, T> optionalVariantVisitor = this.optionalVariantVisitor; + final Function stringVariantVisitor = this.stringVariantVisitor; + final Function unknownVisitor = this.unknownVisitor; + return new Visitor() { + @Override + public T visitCollectionVariant(List value) { + return collectionVariantVisitor.apply(value); + } + + @Override + public T visitIntVariant(int value) { + return intVariantVisitor.apply(value); + } + + @Override + public T visitObjectVariant(ObjectReference value) { + return objectVariantVisitor.apply(value); + } + + @Override + public T visitOptionalVariant(Optional value) { + return optionalVariantVisitor.apply(value); + } + + @Override + public T visitStringVariant(String value) { + return stringVariantVisitor.apply(value); + } + + @Override + public T visitUnknown(String value) { + return unknownVisitor.apply(value); + } + }; + } + } + + public interface CollectionVariantStageVisitorBuilder { + IntVariantStageVisitorBuilder collectionVariant(@Nonnull Function, T> collectionVariantVisitor); + } + + public interface IntVariantStageVisitorBuilder { + ObjectVariantStageVisitorBuilder intVariant(@Nonnull IntFunction intVariantVisitor); + } + + public interface ObjectVariantStageVisitorBuilder { + OptionalVariantStageVisitorBuilder objectVariant(@Nonnull Function objectVariantVisitor); + } + + public interface OptionalVariantStageVisitorBuilder { + StringVariantStageVisitorBuilder optionalVariant( + @Nonnull Function, T> optionalVariantVisitor); + } + + public interface StringVariantStageVisitorBuilder { + UnknownStageVisitorBuilder stringVariant(@Nonnull Function stringVariantVisitor); + } + + public interface UnknownStageVisitorBuilder { + Completed_StageVisitorBuilder unknown(@Nonnull Function unknownVisitor); + + Completed_StageVisitorBuilder throwOnUnknown(); + } + + public interface Completed_StageVisitorBuilder { + Visitor build(); + } + + @JsonTypeInfo( + use = JsonTypeInfo.Id.NAME, + include = JsonTypeInfo.As.EXISTING_PROPERTY, + property = "type", + visible = true, + defaultImpl = UnknownWrapper.class) + @JsonSubTypes({ + @JsonSubTypes.Type(StringVariantWrapper.class), + @JsonSubTypes.Type(IntVariantWrapper.class), + @JsonSubTypes.Type(ObjectVariantWrapper.class), + @JsonSubTypes.Type(CollectionVariantWrapper.class), + @JsonSubTypes.Type(OptionalVariantWrapper.class) + }) + @JsonIgnoreProperties(ignoreUnknown = true) + private interface Base { + T accept(Visitor visitor); + } + + @JsonTypeName("stringVariant") + private static final class StringVariantWrapper implements Base { + private final String value; + + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + private StringVariantWrapper(@JsonSetter("stringVariant") @Nonnull String value) { + Preconditions.checkNotNull(value, "stringVariant cannot be null"); + this.value = value; + } + + @JsonProperty(value = "type", index = 0) + private String getType() { + return "stringVariant"; + } + + @JsonProperty("stringVariant") + private String getValue() { + return value; + } + + @Override + public T accept(Visitor visitor) { + return visitor.visitStringVariant(value); + } + + @Override + public boolean equals(@Nullable Object other) { + return this == other || (other instanceof StringVariantWrapper && equalTo((StringVariantWrapper) other)); + } + + private boolean equalTo(StringVariantWrapper other) { + return this.value.equals(other.value); + } + + @Override + public int hashCode() { + return this.value.hashCode(); + } + + @Override + public String toString() { + return "StringVariantWrapper{value: " + value + '}'; + } + } + + @JsonTypeName("intVariant") + private static final class IntVariantWrapper implements Base { + private final int value; + + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + private IntVariantWrapper(@JsonSetter("intVariant") @Nonnull int value) { + Preconditions.checkNotNull(value, "intVariant cannot be null"); + this.value = value; + } + + @JsonProperty(value = "type", index = 0) + private String getType() { + return "intVariant"; + } + + @JsonProperty("intVariant") + private int getValue() { + return value; + } + + @Override + public T accept(Visitor visitor) { + return visitor.visitIntVariant(value); + } + + @Override + public boolean equals(@Nullable Object other) { + return this == other || (other instanceof IntVariantWrapper && equalTo((IntVariantWrapper) other)); + } + + private boolean equalTo(IntVariantWrapper other) { + return this.value == other.value; + } + + @Override + public int hashCode() { + return this.value; + } + + @Override + public String toString() { + return "IntVariantWrapper{value: " + value + '}'; + } + } + + @JsonTypeName("objectVariant") + private static final class ObjectVariantWrapper implements Base { + private final ObjectReference value; + + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + private ObjectVariantWrapper(@JsonSetter("objectVariant") @Nonnull ObjectReference value) { + Preconditions.checkNotNull(value, "objectVariant cannot be null"); + this.value = value; + } + + @JsonProperty(value = "type", index = 0) + private String getType() { + return "objectVariant"; + } + + @JsonProperty("objectVariant") + private ObjectReference getValue() { + return value; + } + + @Override + public T accept(Visitor visitor) { + return visitor.visitObjectVariant(value); + } + + @Override + public boolean equals(@Nullable Object other) { + return this == other || (other instanceof ObjectVariantWrapper && equalTo((ObjectVariantWrapper) other)); + } + + private boolean equalTo(ObjectVariantWrapper other) { + return this.value.equals(other.value); + } + + @Override + public int hashCode() { + return this.value.hashCode(); + } + + @Override + public String toString() { + return "ObjectVariantWrapper{value: " + value + '}'; + } + } + + @JsonTypeName("collectionVariant") + private static final class CollectionVariantWrapper implements Base { + private final List value; + + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + private CollectionVariantWrapper( + @JsonSetter(value = "collectionVariant", nulls = Nulls.AS_EMPTY) @Nonnull List value) { + Preconditions.checkNotNull(value, "collectionVariant cannot be null"); + this.value = value; + } + + @JsonProperty(value = "type", index = 0) + private String getType() { + return "collectionVariant"; + } + + @JsonProperty("collectionVariant") + private List getValue() { + return value; + } + + @Override + public T accept(Visitor visitor) { + return visitor.visitCollectionVariant(value); + } + + @Override + public boolean equals(@Nullable Object other) { + return this == other + || (other instanceof CollectionVariantWrapper && equalTo((CollectionVariantWrapper) other)); + } + + private boolean equalTo(CollectionVariantWrapper other) { + return this.value.equals(other.value); + } + + @Override + public int hashCode() { + return this.value.hashCode(); + } + + @Override + public String toString() { + return "CollectionVariantWrapper{value: " + value + '}'; + } + } + + @JsonTypeName("optionalVariant") + private static final class OptionalVariantWrapper implements Base { + private final Optional value; + + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + private OptionalVariantWrapper( + @JsonSetter(value = "optionalVariant", nulls = Nulls.AS_EMPTY) @Nonnull Optional value) { + Preconditions.checkNotNull(value, "optionalVariant cannot be null"); + this.value = value; + } + + @JsonProperty(value = "type", index = 0) + private String getType() { + return "optionalVariant"; + } + + @JsonProperty("optionalVariant") + private Optional getValue() { + return value; + } + + @Override + public T accept(Visitor visitor) { + return visitor.visitOptionalVariant(value); + } + + @Override + public boolean equals(@Nullable Object other) { + return this == other + || (other instanceof OptionalVariantWrapper && equalTo((OptionalVariantWrapper) other)); + } + + private boolean equalTo(OptionalVariantWrapper other) { + return this.value.equals(other.value); + } + + @Override + public int hashCode() { + return this.value.hashCode(); + } + + @Override + public String toString() { + return "OptionalVariantWrapper{value: " + value + '}'; + } + } + + private static final class UnknownWrapper implements Base { + private final String type; + + private final Map value; + + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + private UnknownWrapper(@JsonProperty("type") String type) { + this(type, new HashMap()); + } + + private UnknownWrapper(@Nonnull String type, @Nonnull Map value) { + Preconditions.checkNotNull(type, "type cannot be null"); + Preconditions.checkNotNull(value, "value cannot be null"); + this.type = type; + this.value = value; + } + + @JsonProperty + private String getType() { + return type; + } + + @JsonAnyGetter + private Map getValue() { + return value; + } + + @JsonAnySetter + private void put(String key, Object val) { + value.put(key, val); + } + + @Override + public T accept(Visitor visitor) { + return visitor.visitUnknown(type); + } + + @Override + public boolean equals(@Nullable Object other) { + return this == other || (other instanceof UnknownWrapper && equalTo((UnknownWrapper) other)); + } + + private boolean equalTo(UnknownWrapper other) { + return this.type.equals(other.type) && this.value.equals(other.value); + } + + @Override + public int hashCode() { + int hash = 1; + hash = 31 * hash + this.type.hashCode(); + hash = 31 * hash + this.value.hashCode(); + return hash; + } + + @Override + public String toString() { + return "UnknownWrapper{type: " + type + ", value: " + value + '}'; + } + } +} diff --git a/conjure-java-core/src/main/java/com/palantir/conjure/java/Options.java b/conjure-java-core/src/main/java/com/palantir/conjure/java/Options.java index d0c62af8b..b412e24e6 100644 --- a/conjure-java-core/src/main/java/com/palantir/conjure/java/Options.java +++ b/conjure-java-core/src/main/java/com/palantir/conjure/java/Options.java @@ -202,6 +202,15 @@ default boolean dangerousDoNotUseEnableEndpointAssociatedErrors() { return false; } + /** + * TODO. + */ + @Value.Default + @Beta + default boolean deserializeErrorResponsesAsJson() { + return false; + } + /** * Makes immutable copies of collections for union and alias types, respecting the --nonNullCollections flag. */ diff --git a/conjure-java-core/src/main/java/com/palantir/conjure/java/services/dialogue/DefaultStaticFactoryMethodGenerator.java b/conjure-java-core/src/main/java/com/palantir/conjure/java/services/dialogue/DefaultStaticFactoryMethodGenerator.java index fa49fdf0f..9864d625b 100644 --- a/conjure-java-core/src/main/java/com/palantir/conjure/java/services/dialogue/DefaultStaticFactoryMethodGenerator.java +++ b/conjure-java-core/src/main/java/com/palantir/conjure/java/services/dialogue/DefaultStaticFactoryMethodGenerator.java @@ -18,6 +18,7 @@ import com.google.common.collect.ImmutableMap; import com.palantir.conjure.java.Options; import com.palantir.conjure.java.services.Auth; +import com.palantir.conjure.java.util.ErrorGenerationUtils.PackageToErrorDefinitionsMapping; import com.palantir.conjure.java.util.Primitives; import com.palantir.conjure.spec.ArgumentDefinition; import com.palantir.conjure.spec.AuthType; @@ -75,18 +76,21 @@ public final class DefaultStaticFactoryMethodGenerator implements StaticFactoryM private final ParameterTypeMapper parameterTypes; private final ReturnTypeMapper returnTypes; private final StaticFactoryMethodType methodType; + private final PackageToErrorDefinitionsMapping packageToErrorDefinitionsMapping; public DefaultStaticFactoryMethodGenerator( Options options, TypeNameResolver typeNameResolver, ParameterTypeMapper parameterTypes, ReturnTypeMapper returnTypes, - StaticFactoryMethodType methodType) { + StaticFactoryMethodType methodType, + PackageToErrorDefinitionsMapping packageToErrorDefinitionsMapping) { this.options = options; this.typeNameResolver = typeNameResolver; this.parameterTypes = parameterTypes; this.returnTypes = returnTypes; this.methodType = methodType; + this.packageToErrorDefinitionsMapping = packageToErrorDefinitionsMapping; } @Override @@ -169,7 +173,11 @@ private Optional deserializer(EndpointName endpointName, Optional type, TypeName className) : CodeBlock.of("emptyBodyDeserializer()"); } + private CodeBlock constructDeserializerWithExceptions(Optional type, TypeName className) { + CodeBlock.Builder builder = CodeBlock.builder(); + if (type.isEmpty()) { + builder.add("emptyBodyDeserializer("); + } else if (returnTypes.isBinary(className)) { + builder.add("inputStreamDeserializer("); + } else if (returnTypes.isOptionalBinary(className)) { + builder.add("optionalInputStreamDeserializer("); + } else { + builder.add("deserializer("); + } + return builder.add("createExceptionDeserializerArgs(new $T<$T>() {}))", TypeMarker.class, className) + .build(); + } + private MethodSpec clientImpl(EndpointDefinition def) { List params = parameterTypes.implementationMethodParams(def); MethodSpec.Builder methodBuilder = MethodSpec.methodBuilder( diff --git a/conjure-java-core/src/main/java/com/palantir/conjure/java/services/dialogue/DialogueServiceGenerator.java b/conjure-java-core/src/main/java/com/palantir/conjure/java/services/dialogue/DialogueServiceGenerator.java index a966afa7e..2bc4cf804 100644 --- a/conjure-java-core/src/main/java/com/palantir/conjure/java/services/dialogue/DialogueServiceGenerator.java +++ b/conjure-java-core/src/main/java/com/palantir/conjure/java/services/dialogue/DialogueServiceGenerator.java @@ -22,6 +22,7 @@ import com.palantir.conjure.java.types.SafetyEvaluator; import com.palantir.conjure.java.types.SpecializeBinaryClassNameVisitor; import com.palantir.conjure.java.types.TypeMapper; +import com.palantir.conjure.java.util.ErrorGenerationUtils.PackageToErrorDefinitionsMapping; import com.palantir.conjure.java.util.TypeFunctions; import com.palantir.conjure.spec.ConjureDefinition; import com.palantir.conjure.spec.ServiceDefinition; @@ -70,19 +71,23 @@ public Stream generate(ConjureDefinition conjureDefinition) { TypeNameResolver typeNameResolver = typeName -> Preconditions.checkNotNull( types.get(typeName), "Referenced unknown TypeName", SafeArg.of("typeName", typeName)); + PackageToErrorDefinitionsMapping packageToErrorDefinitionsMapping = + PackageToErrorDefinitionsMapping.from(conjureDefinition); StaticFactoryMethodGenerator asyncGenerator = new DefaultStaticFactoryMethodGenerator( options, typeNameResolver, parameterMapper, new ReturnTypeMapper(returnTypes), - StaticFactoryMethodType.ASYNC); + StaticFactoryMethodType.ASYNC, + packageToErrorDefinitionsMapping); StaticFactoryMethodGenerator blockingGenerator = new DefaultStaticFactoryMethodGenerator( options, typeNameResolver, parameterMapper, new ReturnTypeMapper(returnTypes), - StaticFactoryMethodType.BLOCKING); + StaticFactoryMethodType.BLOCKING, + packageToErrorDefinitionsMapping); return conjureDefinition.getServices().stream() .flatMap(serviceDef -> generateFilesForService( diff --git a/conjure-java-core/src/main/java/com/palantir/conjure/java/util/ErrorGenerationUtils.java b/conjure-java-core/src/main/java/com/palantir/conjure/java/util/ErrorGenerationUtils.java index f8c0d1220..e3f908736 100644 --- a/conjure-java-core/src/main/java/com/palantir/conjure/java/util/ErrorGenerationUtils.java +++ b/conjure-java-core/src/main/java/com/palantir/conjure/java/util/ErrorGenerationUtils.java @@ -77,6 +77,24 @@ public static ParameterSpec buildParameterWithSafetyAnnotationAndJsonProperty( return parameterBuilder.build(); } + /** + * A mapping from a package name to the list of errors defined within that package. This is used when attempting to + * deserialize error responses from endpoints. + * + * TODO(pm): does this work with imported errors? + */ + public record PackageToErrorDefinitionsMapping(Map> packageToErrors) { + public static PackageToErrorDefinitionsMapping from(ConjureDefinition definition) { + Map> fromDefinition = definition.getErrors().stream() + .collect(Collectors.groupingBy(error -> error.getErrorName().getPackage(), Collectors.toList())); + return new PackageToErrorDefinitionsMapping(fromDefinition); + } + + public List get(String packageName) { + return packageToErrors.getOrDefault(packageName, ImmutableList.of()); + } + } + public record DeclaredEndpointErrors(Set errors) { public static DeclaredEndpointErrors from(ConjureDefinition definition) { return new DeclaredEndpointErrors(definition.getServices().stream() diff --git a/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowEteResource.java b/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowEteResource.java index 012ac98cc..1fd334de4 100644 --- a/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowEteResource.java +++ b/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowEteResource.java @@ -37,7 +37,7 @@ import errors.com.palantir.product.OptionalExample; import errors.com.palantir.product.PrimitiveExample; import errors.com.palantir.product.SafetyExample; -import errors.com.palantir.product.StringAlias; +import errors.com.palantir.product.StringAliasEx; import errors.com.palantir.product.UnionExample; import jakarta.validation.constraints.NotNull; import jakarta.ws.rs.core.StreamingOutput; @@ -248,10 +248,10 @@ public String errorParameterSerialization(AuthHeader authHeader, String headerPa .build(), UnionExample.stringVariant("union-string-value"), EnumExample.A, - StringAlias.of("aliased-string"), + StringAliasEx.of("aliased-string"), OptionalAlias.of(Optional.of("optional-aliased-string")), CollectionAlias.of(List.of("alias1", "alias2", "alias3")), - NestedAlias.of(StringAlias.of("nested-alias-value")), + NestedAlias.of(StringAliasEx.of("nested-alias-value")), ExternalExample.builder() .externalLong(456L) .optionalExternal(Optional.of(789L)) @@ -272,7 +272,7 @@ public String errorParameterSerialization(AuthHeader authHeader, String headerPa EmptyObject.of(), ComplexExample.builder() .metadata(Map.of( - StringAlias.of("meta1"), + StringAliasEx.of("meta1"), Optional.of(List.of( ObjectReference.builder() .name("complex1") @@ -282,7 +282,7 @@ public String errorParameterSerialization(AuthHeader authHeader, String headerPa .name("complex2") .value(2) .build())), - StringAlias.of("meta2"), Optional.empty())) + StringAliasEx.of("meta2"), Optional.empty())) .status(EnumExample.B) .variants(List.of( UnionExample.intVariant(42), diff --git a/conjure-java-core/src/test/java/com/palantir/conjure/java/parameterized/TestCases.java b/conjure-java-core/src/test/java/com/palantir/conjure/java/parameterized/TestCases.java index ee8f89eb8..6cf03b797 100644 --- a/conjure-java-core/src/test/java/com/palantir/conjure/java/parameterized/TestCases.java +++ b/conjure-java-core/src/test/java/com/palantir/conjure/java/parameterized/TestCases.java @@ -176,7 +176,10 @@ public final class TestCases { .files(Path.of("ete-service.yml")) .files(Path.of("ete-binary.yml")) .files(Path.of("example-errors.yml")) - .options(Options.builder().apiVersion("1.2.3").build()) + .options(Options.builder() + .apiVersion("1.2.3") + .deserializeErrorResponsesAsJson(true) + .build()) .generatorTypes(List.of(GeneratorType.DIALOGUE, GeneratorType.OBJECT, GeneratorType.ERROR)) .build()) .add(ParameterizedTestCase.builder() diff --git a/conjure-java-core/src/test/resources/ete-service.yml b/conjure-java-core/src/test/resources/ete-service.yml index 9f82a7ff7..38df0d8ae 100644 --- a/conjure-java-core/src/test/resources/ete-service.yml +++ b/conjure-java-core/src/test/resources/ete-service.yml @@ -1,4 +1,8 @@ types: + # This is needed because Conjure needs to know the errors that could be thrown. Every error defined in the imported + # files that is part of the same package as a service will be respected. + conjure-imports: + errors: example-errors.yml imports: StringAliasExampleImport: base-type: string diff --git a/conjure-java-core/src/test/resources/example-endpoint-errors.yml b/conjure-java-core/src/test/resources/example-endpoint-errors.yml index 464ffaa70..929500640 100644 --- a/conjure-java-core/src/test/resources/example-endpoint-errors.yml +++ b/conjure-java-core/src/test/resources/example-endpoint-errors.yml @@ -33,7 +33,7 @@ types: code: INTERNAL safe-args: complicatedObjectMap: map - ConflictingCauseSafeArg: + ConflictingCauseSafeArgErr: namespace: Conjure docs: Cause argument conflicts with reserved Throwable cause parameter. code: INTERNAL @@ -54,7 +54,7 @@ services: returns: string errors: - InvalidArgument - - ConflictingCauseSafeArg + - ConflictingCauseSafeArgErr testImportedError: http: POST /imported args: diff --git a/conjure-java/src/main/java/com/palantir/conjure/java/cli/ConjureJavaCli.java b/conjure-java/src/main/java/com/palantir/conjure/java/cli/ConjureJavaCli.java index e26a75f45..f477ff556 100644 --- a/conjure-java/src/main/java/com/palantir/conjure/java/cli/ConjureJavaCli.java +++ b/conjure-java/src/main/java/com/palantir/conjure/java/cli/ConjureJavaCli.java @@ -246,6 +246,9 @@ public static final class GenerateCommand implements Runnable { + "This feature is currently not supported.") private boolean dangerousDoNotUseEnableEndpointAssociatedErrors; + @CommandLine.Option(names = "--deserializeErrorResponsesAsJson", defaultValue = "false", description = "TODO.") + private boolean deserializeErrorResponsesAsJson; + @SuppressWarnings("unused") @CommandLine.Unmatched private List unmatchedOptions; @@ -320,6 +323,7 @@ CliConfiguration getConfiguration() { .defensiveCollections(defensiveCollections) .dangerousDoNotUseEnableEndpointAssociatedErrors( dangerousDoNotUseEnableEndpointAssociatedErrors) + .deserializeErrorResponsesAsJson(deserializeErrorResponsesAsJson) .build()) .build(); } From 094d44f134e1278693e51f9a941e2c096aa22a89 Mon Sep 17 00:00:00 2001 From: Pritham Marupaka Date: Tue, 12 Aug 2025 11:24:27 -0400 Subject: [PATCH 09/26] Generate code and add basic test --- .../com/palantir/product/ConjureErrors.java | 292 ++++++++++++++++++ .../palantir/product/ConjureJavaErrors.java | 48 +++ .../product/EmptyPathServiceAsync.java | 8 + .../product/EmptyPathServiceBlocking.java | 8 + .../product/EteBinaryServiceAsync.java | 48 +++ .../product/EteBinaryServiceBlocking.java | 48 +++ .../com/palantir/product/EteServiceAsync.java | 264 ++++++++++++++++ .../palantir/product/EteServiceBlocking.java | 273 +++++++++++++++- .../dialogue/test/api/CookieServiceAsync.java | 8 + .../test/api/CookieServiceBlocking.java | 8 + .../another/EndpointSpecificErrors.java | 22 +- .../com/palantir/product/ConjureErrors.java | 27 +- .../product/EndpointSpecificErrors.java | 26 +- .../product/EndpointSpecificTwoErrors.java | 22 +- .../palantir/product/ErrorServiceAsync.java | 48 +++ .../product/ErrorServiceBlocking.java | 48 +++ .../com/palantir/product/TestErrors.java | 72 +++-- .../com/palantir/another/ConjureErrors.java | 22 +- .../another/ConjureJavaOtherErrors.java | 22 +- .../com/palantir/product/ConjureErrors.java | 188 ++++++----- .../palantir/product/ConjureJavaErrors.java | 22 +- .../palantir/another/TestServiceBlocking.java | 176 +++++++++++ .../ServiceUsingExternalTypesAsync.java | 8 + .../ServiceUsingExternalTypesBlocking.java | 8 + .../palantir/another/TestServiceAsync.java | 176 +++++++++++ .../palantir/another/TestServiceBlocking.java | 176 +++++++++++ .../test/api/CookieServiceAsync.java | 8 + .../test/api/CookieServiceBlocking.java | 8 + .../com/palantir/another/ConjureErrors.java | 22 +- .../another/EndpointSpecificErrors.java | 22 +- .../com/palantir/product/ConjureErrors.java | 214 ++++++++----- .../palantir/product/ConjureJavaErrors.java | 22 +- .../product/EndpointSpecificErrors.java | 26 +- .../product/EndpointSpecificTwoErrors.java | 22 +- .../com/palantir/product/TestErrors.java | 72 +++-- .../DefaultStaticFactoryMethodGenerator.java | 11 + .../conjure/java/types/ErrorGenerator.java | 39 ++- .../conjure/java/UndertowEteResource.java | 2 +- .../conjure/java/UndertowServiceEteTest.java | 20 +- .../ParameterizedConjureGenerationTest.java | 19 -- .../java/undertow/runtime/ConjureError.java | 54 +++- .../undertow/runtime/ConjureExceptions.java | 30 +- .../runtime/ConjureExceptionHandlerTest.java | 3 + 43 files changed, 2291 insertions(+), 371 deletions(-) diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureErrors.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureErrors.java index b8ab5e6bf..3ab301e33 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureErrors.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureErrors.java @@ -1,13 +1,19 @@ package dialogue.com.palantir.product; +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.palantir.conjure.java.api.errors.AbstractSerializableError; import com.palantir.conjure.java.api.errors.ErrorType; import com.palantir.conjure.java.api.errors.RemoteException; +import com.palantir.conjure.java.api.errors.SerializableError; import com.palantir.conjure.java.api.errors.ServiceException; import com.palantir.logsafe.Preconditions; import com.palantir.logsafe.Safe; import com.palantir.logsafe.SafeArg; import com.palantir.logsafe.Unsafe; import com.palantir.logsafe.UnsafeArg; +import java.util.Map; +import java.util.Objects; import javax.annotation.Nullable; import javax.annotation.processing.Generated; @@ -324,4 +330,290 @@ public static boolean isInvalidTypeDefinition(RemoteException remoteException) { Preconditions.checkNotNull(remoteException, "remote exception must not be null"); return INVALID_TYPE_DEFINITION.name().equals(remoteException.getError().errorName()); } + public static record ConflictingCauseSafeArgParameters( + @JsonProperty("cause") @Safe String cause_, @JsonProperty("shouldThrow") @Safe boolean shouldThrow_) {} + + public static record ConflictingCauseUnsafeArgParameters( + @JsonProperty("cause") @Unsafe String cause_, @JsonProperty("shouldThrow") @Unsafe boolean shouldThrow_) {} + + public static record ErrorWithComplexArgsParameters( + @JsonProperty("primitiveExample") @Safe PrimitiveExample primitiveExample, + @JsonProperty("collectionExample") @Safe CollectionExample collectionExample, + @JsonProperty("nestedCollectionExample") @Safe NestedCollectionExample nestedCollectionExample, + @JsonProperty("optionalExample") @Safe OptionalExample optionalExample, + @JsonProperty("objectReference") @Safe ObjectReference objectReference, + @JsonProperty("unionExample") @Safe UnionExample unionExample, + @JsonProperty("enumExample") @Safe EnumExample enumExample, + @JsonProperty("stringAlias") @Safe StringAliasEx stringAlias, + @JsonProperty("optionalAlias") @Safe OptionalAlias optionalAlias, + @JsonProperty("collectionAlias") @Safe CollectionAlias collectionAlias, + @JsonProperty("nestedAlias") @Safe NestedAlias nestedAlias, + @JsonProperty("externalExample") @Safe ExternalExample externalExample, + @JsonProperty("anyExample") @Safe AnyExample anyExample, + @JsonProperty("emptyObject") @Safe EmptyObject emptyObject, + @JsonProperty("complexExample") @Safe ComplexExample complexExample, + @JsonProperty("safetyExample") @Unsafe SafetyExample safetyExample) {} + + /** + * @param serviceName Name of the invalid service definition. + * @param serviceDef Details of the invalid service definition. + */ + public static record InvalidServiceDefinitionParameters( + @JsonProperty("serviceName") @Safe String serviceName, + @JsonProperty("serviceDef") @Unsafe Object serviceDef) {} + + public static record InvalidTypeDefinitionParameters( + @JsonProperty("typeName") @Safe String typeName, @JsonProperty("typeDef") @Unsafe Object typeDef) {} + + public static final class ConflictingCauseSafeArgSerializableError + extends AbstractSerializableError { + @org.jspecify.annotations.Nullable + private final Map legacyParameters; + + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + ConflictingCauseSafeArgSerializableError( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorName") @Safe String errorName, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") ConflictingCauseSafeArgParameters parameters, + @JsonProperty("legacyParameters") @org.jspecify.annotations.Nullable + Map legacyParameters) { + super(errorCode, errorName, errorInstanceId, parameters); + this.legacyParameters = legacyParameters; + } + + public SerializableError toSerializableError() { + SerializableError.Builder builder = SerializableError.builder(); + if (legacyParameters != null) { + builder.putAllParameters(legacyParameters); + } else { + builder.putParameters("cause", Objects.toString(parameters().cause_())) + .putParameters( + "shouldThrow", Objects.toString(parameters().shouldThrow_())); + } + builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); + return builder.build(); + } + } + + public static final class ConflictingCauseUnsafeArgSerializableError + extends AbstractSerializableError { + @org.jspecify.annotations.Nullable + private final Map legacyParameters; + + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + ConflictingCauseUnsafeArgSerializableError( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorName") @Safe String errorName, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") ConflictingCauseUnsafeArgParameters parameters, + @JsonProperty("legacyParameters") @org.jspecify.annotations.Nullable + Map legacyParameters) { + super(errorCode, errorName, errorInstanceId, parameters); + this.legacyParameters = legacyParameters; + } + + public SerializableError toSerializableError() { + SerializableError.Builder builder = SerializableError.builder(); + if (legacyParameters != null) { + builder.putAllParameters(legacyParameters); + } else { + builder.putParameters("cause", Objects.toString(parameters().cause_())) + .putParameters( + "shouldThrow", Objects.toString(parameters().shouldThrow_())); + } + builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); + return builder.build(); + } + } + + public static final class ErrorWithComplexArgsSerializableError + extends AbstractSerializableError { + @org.jspecify.annotations.Nullable + private final Map legacyParameters; + + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + ErrorWithComplexArgsSerializableError( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorName") @Safe String errorName, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") ErrorWithComplexArgsParameters parameters, + @JsonProperty("legacyParameters") @org.jspecify.annotations.Nullable + Map legacyParameters) { + super(errorCode, errorName, errorInstanceId, parameters); + this.legacyParameters = legacyParameters; + } + + public SerializableError toSerializableError() { + SerializableError.Builder builder = SerializableError.builder(); + if (legacyParameters != null) { + builder.putAllParameters(legacyParameters); + } else { + builder.putParameters( + "primitiveExample", + Objects.toString(parameters().primitiveExample())) + .putParameters( + "collectionExample", + Objects.toString(parameters().collectionExample())) + .putParameters( + "nestedCollectionExample", + Objects.toString(parameters().nestedCollectionExample())) + .putParameters( + "optionalExample", Objects.toString(parameters().optionalExample())) + .putParameters( + "objectReference", Objects.toString(parameters().objectReference())) + .putParameters( + "unionExample", Objects.toString(parameters().unionExample())) + .putParameters( + "enumExample", Objects.toString(parameters().enumExample())) + .putParameters( + "stringAlias", Objects.toString(parameters().stringAlias())) + .putParameters( + "optionalAlias", Objects.toString(parameters().optionalAlias())) + .putParameters( + "collectionAlias", Objects.toString(parameters().collectionAlias())) + .putParameters( + "nestedAlias", Objects.toString(parameters().nestedAlias())) + .putParameters( + "externalExample", Objects.toString(parameters().externalExample())) + .putParameters( + "anyExample", Objects.toString(parameters().anyExample())) + .putParameters( + "emptyObject", Objects.toString(parameters().emptyObject())) + .putParameters( + "complexExample", Objects.toString(parameters().complexExample())) + .putParameters( + "safetyExample", Objects.toString(parameters().safetyExample())); + } + builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); + return builder.build(); + } + } + + public static final class InvalidServiceDefinitionSerializableError + extends AbstractSerializableError { + @org.jspecify.annotations.Nullable + private final Map legacyParameters; + + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + InvalidServiceDefinitionSerializableError( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorName") @Safe String errorName, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") InvalidServiceDefinitionParameters parameters, + @JsonProperty("legacyParameters") @org.jspecify.annotations.Nullable + Map legacyParameters) { + super(errorCode, errorName, errorInstanceId, parameters); + this.legacyParameters = legacyParameters; + } + + public SerializableError toSerializableError() { + SerializableError.Builder builder = SerializableError.builder(); + if (legacyParameters != null) { + builder.putAllParameters(legacyParameters); + } else { + builder.putParameters( + "serviceName", Objects.toString(parameters().serviceName())) + .putParameters( + "serviceDef", Objects.toString(parameters().serviceDef())); + } + builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); + return builder.build(); + } + } + + public static final class InvalidTypeDefinitionSerializableError + extends AbstractSerializableError { + @org.jspecify.annotations.Nullable + private final Map legacyParameters; + + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + InvalidTypeDefinitionSerializableError( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorName") @Safe String errorName, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") InvalidTypeDefinitionParameters parameters, + @JsonProperty("legacyParameters") @org.jspecify.annotations.Nullable + Map legacyParameters) { + super(errorCode, errorName, errorInstanceId, parameters); + this.legacyParameters = legacyParameters; + } + + public SerializableError toSerializableError() { + SerializableError.Builder builder = SerializableError.builder(); + if (legacyParameters != null) { + builder.putAllParameters(legacyParameters); + } else { + builder.putParameters("typeName", Objects.toString(parameters().typeName())) + .putParameters("typeDef", Objects.toString(parameters().typeDef())); + } + builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); + return builder.build(); + } + } + + public static final class ConflictingCauseSafeArgException extends RemoteException { + private ConflictingCauseSafeArgSerializableError error; + + public ConflictingCauseSafeArgException(ConflictingCauseSafeArgSerializableError error, int status) { + super(error.toSerializableError(), status); + this.error = error; + } + + public ConflictingCauseSafeArgSerializableError error() { + return error; + } + } + + public static final class ConflictingCauseUnsafeArgException extends RemoteException { + private ConflictingCauseUnsafeArgSerializableError error; + + public ConflictingCauseUnsafeArgException(ConflictingCauseUnsafeArgSerializableError error, int status) { + super(error.toSerializableError(), status); + this.error = error; + } + + public ConflictingCauseUnsafeArgSerializableError error() { + return error; + } + } + + public static final class ErrorWithComplexArgsException extends RemoteException { + private ErrorWithComplexArgsSerializableError error; + + public ErrorWithComplexArgsException(ErrorWithComplexArgsSerializableError error, int status) { + super(error.toSerializableError(), status); + this.error = error; + } + + public ErrorWithComplexArgsSerializableError error() { + return error; + } + } + + public static final class InvalidServiceDefinitionException extends RemoteException { + private InvalidServiceDefinitionSerializableError error; + + public InvalidServiceDefinitionException(InvalidServiceDefinitionSerializableError error, int status) { + super(error.toSerializableError(), status); + this.error = error; + } + + public InvalidServiceDefinitionSerializableError error() { + return error; + } + } + + public static final class InvalidTypeDefinitionException extends RemoteException { + private InvalidTypeDefinitionSerializableError error; + + public InvalidTypeDefinitionException(InvalidTypeDefinitionSerializableError error, int status) { + super(error.toSerializableError(), status); + this.error = error; + } + + public InvalidTypeDefinitionSerializableError error() { + return error; + } + } } diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureJavaErrors.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureJavaErrors.java index def54f2f8..3e809c7fc 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureJavaErrors.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureJavaErrors.java @@ -1,9 +1,15 @@ package dialogue.com.palantir.product; +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.palantir.conjure.java.api.errors.AbstractSerializableError; import com.palantir.conjure.java.api.errors.ErrorType; import com.palantir.conjure.java.api.errors.RemoteException; +import com.palantir.conjure.java.api.errors.SerializableError; import com.palantir.conjure.java.api.errors.ServiceException; import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.Safe; +import java.util.Map; import javax.annotation.Nullable; import javax.annotation.processing.Generated; @@ -39,4 +45,46 @@ public static boolean isJavaCompilationFailed(RemoteException remoteException) { Preconditions.checkNotNull(remoteException, "remote exception must not be null"); return JAVA_COMPILATION_FAILED.name().equals(remoteException.getError().errorName()); } + public static record JavaCompilationFailedParameters() {} + + public static final class JavaCompilationFailedSerializableError + extends AbstractSerializableError { + @org.jspecify.annotations.Nullable + private final Map legacyParameters; + + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + JavaCompilationFailedSerializableError( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorName") @Safe String errorName, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") JavaCompilationFailedParameters parameters, + @JsonProperty("legacyParameters") @org.jspecify.annotations.Nullable + Map legacyParameters) { + super(errorCode, errorName, errorInstanceId, parameters); + this.legacyParameters = legacyParameters; + } + + public SerializableError toSerializableError() { + SerializableError.Builder builder = SerializableError.builder(); + if (legacyParameters != null) { + builder.putAllParameters(legacyParameters); + } else { + } + builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); + return builder.build(); + } + } + + public static final class JavaCompilationFailedException extends RemoteException { + private JavaCompilationFailedSerializableError error; + + public JavaCompilationFailedException(JavaCompilationFailedSerializableError error, int status) { + super(error.toSerializableError(), status); + this.error = error; + } + + public JavaCompilationFailedSerializableError error() { + return error; + } + } } diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceAsync.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceAsync.java index 6d195c014..599dc7084 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceAsync.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceAsync.java @@ -67,6 +67,14 @@ static EmptyPathServiceAsync of(EndpointChannelFactory _endpointChannelFactory, @Override public ListenableFuture emptyPath() { Request.Builder _request = Request.builder(); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().call(emptyPathChannel, _request.build(), emptyPathDeserializer); } diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceBlocking.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceBlocking.java index 14180963d..646d1c606 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceBlocking.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceBlocking.java @@ -66,6 +66,14 @@ static EmptyPathServiceBlocking of(EndpointChannelFactory _endpointChannelFactor @Override public boolean emptyPath() { Request.Builder _request = Request.builder(); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().callBlocking(emptyPathChannel, _request.build(), emptyPathDeserializer); } diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceAsync.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceAsync.java index 0475a8808..c55ed3f47 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceAsync.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceAsync.java @@ -78,6 +78,14 @@ public ListenableFuture postBinary(AuthHeader authHeader, BinaryReq Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(_runtime.bodySerDe().serialize(body)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .call( postBinaryChannel, @@ -92,6 +100,14 @@ public ListenableFuture postBinaryThrows( _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(_runtime.bodySerDe().serialize(body)); _request.putQueryParams("bytesToRead", _plainSerDe.serializeInteger(bytesToRead)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .call( postBinaryThrowsChannel, @@ -103,6 +119,14 @@ public ListenableFuture postBinaryThrows( public ListenableFuture> getOptionalBinaryPresent(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .call( getOptionalBinaryPresentChannel, @@ -114,6 +138,14 @@ public ListenableFuture> getOptionalBinaryPresent(AuthHead public ListenableFuture> getOptionalBinaryEmpty(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .call( getOptionalBinaryEmptyChannel, @@ -128,6 +160,14 @@ public ListenableFuture getBinaryFailure( _request.putHeaderParams("Authorization", authHeader.toString()); _request.putQueryParams("numBytes", _plainSerDe.serializeInteger(numBytes)); _request.putQueryParams("useTryWithResources", _plainSerDe.serializeBoolean(useTryWithResources)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .call( getBinaryFailureChannel, @@ -139,6 +179,14 @@ public ListenableFuture getBinaryFailure( public ListenableFuture> getAliased(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .call( getAliasedChannel, diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceBlocking.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceBlocking.java index 57533e186..f8d00aa65 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceBlocking.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceBlocking.java @@ -81,6 +81,14 @@ public InputStream postBinary(AuthHeader authHeader, BinaryRequestBody body) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(_runtime.bodySerDe().serialize(body)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .callBlocking( postBinaryChannel, @@ -94,6 +102,14 @@ public InputStream postBinaryThrows(AuthHeader authHeader, int bytesToRead, Bina _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(_runtime.bodySerDe().serialize(body)); _request.putQueryParams("bytesToRead", _plainSerDe.serializeInteger(bytesToRead)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .callBlocking( postBinaryThrowsChannel, @@ -105,6 +121,14 @@ public InputStream postBinaryThrows(AuthHeader authHeader, int bytesToRead, Bina public Optional getOptionalBinaryPresent(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .callBlocking( getOptionalBinaryPresentChannel, @@ -116,6 +140,14 @@ public Optional getOptionalBinaryPresent(AuthHeader authHeader) { public Optional getOptionalBinaryEmpty(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .callBlocking( getOptionalBinaryEmptyChannel, @@ -129,6 +161,14 @@ public InputStream getBinaryFailure(AuthHeader authHeader, int numBytes, boolean _request.putHeaderParams("Authorization", authHeader.toString()); _request.putQueryParams("numBytes", _plainSerDe.serializeInteger(numBytes)); _request.putQueryParams("useTryWithResources", _plainSerDe.serializeBoolean(useTryWithResources)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .callBlocking( getBinaryFailureChannel, @@ -140,6 +180,14 @@ public InputStream getBinaryFailure(AuthHeader authHeader, int numBytes, boolean public Optional getAliased(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .callBlocking( getAliasedChannel, diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceAsync.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceAsync.java index 3afa81f3a..60313fdd1 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceAsync.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceAsync.java @@ -1354,6 +1354,14 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur public ListenableFuture string(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().call(stringChannel, _request.build(), stringDeserializer); } @@ -1361,6 +1369,14 @@ public ListenableFuture string(AuthHeader authHeader) { public ListenableFuture integer(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().call(integerChannel, _request.build(), integerDeserializer); } @@ -1368,6 +1384,14 @@ public ListenableFuture integer(AuthHeader authHeader) { public ListenableFuture double_(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().call(double_Channel, _request.build(), double_Deserializer); } @@ -1375,6 +1399,14 @@ public ListenableFuture double_(AuthHeader authHeader) { public ListenableFuture boolean_(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().call(boolean_Channel, _request.build(), boolean_Deserializer); } @@ -1382,6 +1414,14 @@ public ListenableFuture boolean_(AuthHeader authHeader) { public ListenableFuture safelong(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().call(safelongChannel, _request.build(), safelongDeserializer); } @@ -1389,6 +1429,14 @@ public ListenableFuture safelong(AuthHeader authHeader) { public ListenableFuture rid(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().call(ridChannel, _request.build(), ridDeserializer); } @@ -1396,6 +1444,14 @@ public ListenableFuture rid(AuthHeader authHeader) { public ListenableFuture bearertoken(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().call(bearertokenChannel, _request.build(), bearertokenDeserializer); } @@ -1403,6 +1459,14 @@ public ListenableFuture bearertoken(AuthHeader authHeader) { public ListenableFuture> optionalString(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().call(optionalStringChannel, _request.build(), optionalStringDeserializer); } @@ -1410,6 +1474,14 @@ public ListenableFuture> optionalString(AuthHeader authHeader) public ListenableFuture> optionalEmpty(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().call(optionalEmptyChannel, _request.build(), optionalEmptyDeserializer); } @@ -1417,6 +1489,14 @@ public ListenableFuture> optionalEmpty(AuthHeader authHeader) { public ListenableFuture datetime(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().call(datetimeChannel, _request.build(), datetimeDeserializer); } @@ -1424,6 +1504,14 @@ public ListenableFuture datetime(AuthHeader authHeader) { public ListenableFuture binary(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .call( binaryChannel, @@ -1436,6 +1524,14 @@ public ListenableFuture path(AuthHeader authHeader, String param) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("param", _plainSerDe.serializeString(param)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().call(pathChannel, _request.build(), pathDeserializer); } @@ -1444,6 +1540,14 @@ public ListenableFuture externalLongPath(AuthHeader authHeader, long param Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("param", Objects.toString(param)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().call(externalLongPathChannel, _request.build(), externalLongPathDeserializer); } @@ -1455,6 +1559,14 @@ public ListenableFuture> optionalExternalLongQuery( if (param.isPresent()) { _request.putQueryParams("param", Objects.toString(param.get())); } + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .call( optionalExternalLongQueryChannel, @@ -1468,6 +1580,14 @@ public ListenableFuture notNullBody( Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(notNullBodySerializer.serialize(notNullBody)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().call(notNullBodyChannel, _request.build(), notNullBodyDeserializer); } @@ -1477,6 +1597,14 @@ public ListenableFuture aliasOne( Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putQueryParams("queryParamName", _plainSerDe.serializeString(queryParamName.get())); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().call(aliasOneChannel, _request.build(), aliasOneDeserializer); } @@ -1490,6 +1618,14 @@ public ListenableFuture optionalAliasOne( "queryParamName", _plainSerDe.serializeString(queryParamName.get().get())); } + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().call(optionalAliasOneChannel, _request.build(), optionalAliasOneDeserializer); } @@ -1501,6 +1637,14 @@ public ListenableFuture aliasTwo( _request.putQueryParams( "queryParamName", _plainSerDe.serializeString(queryParamName.get().get())); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().call(aliasTwoChannel, _request.build(), aliasTwoDeserializer); } @@ -1510,6 +1654,14 @@ public ListenableFuture not Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(notNullBodyExternalImportSerializer.serialize(notNullBody)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .call( notNullBodyExternalImportChannel, @@ -1524,6 +1676,14 @@ public ListenableFuture not Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(optionalBodyExternalImportSerializer.serialize(body)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .call( optionalBodyExternalImportChannel, @@ -1541,6 +1701,14 @@ public ListenableFuture not if (query.isPresent()) { _request.putQueryParams("query", Objects.toString(query.get())); } + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .call( optionalQueryExternalImportChannel, @@ -1552,6 +1720,14 @@ public ListenableFuture not public ListenableFuture noReturn(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().call(noReturnChannel, _request.build(), noReturnDeserializer); } @@ -1560,6 +1736,14 @@ public ListenableFuture enumQuery(AuthHeader authHeader, SimpleEnum Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putQueryParams("queryParamName", Objects.toString(queryParamName)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().call(enumQueryChannel, _request.build(), enumQueryDeserializer); } @@ -1571,6 +1755,14 @@ public ListenableFuture> enumListQuery( for (SimpleEnum queryParamNameElement : queryParamName) { _request.putQueryParams("queryParamName", Objects.toString(queryParamNameElement)); } + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().call(enumListQueryChannel, _request.build(), enumListQueryDeserializer); } @@ -1582,6 +1774,14 @@ public ListenableFuture> optionalEnumQuery( if (queryParamName.isPresent()) { _request.putQueryParams("queryParamName", Objects.toString(queryParamName.get())); } + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .call(optionalEnumQueryChannel, _request.build(), optionalEnumQueryDeserializer); } @@ -1591,6 +1791,14 @@ public ListenableFuture enumHeader(AuthHeader authHeader, SimpleEnum Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putHeaderParams("Custom-Header", Objects.toString(headerParameter)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().call(enumHeaderChannel, _request.build(), enumHeaderDeserializer); } @@ -1600,6 +1808,14 @@ public ListenableFuture jsonErrorsHeader(AuthHeader authHeader, String h _request.putHeaderParams("Authorization", authHeader.toString()); _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", _plainSerDe.serializeString(headerParameter)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().call(jsonErrorsHeaderChannel, _request.build(), jsonErrorsHeaderDeserializer); } @@ -1609,6 +1825,14 @@ public ListenableFuture errorParameterSerialization(AuthHeader authHeade _request.putHeaderParams("Authorization", authHeader.toString()); _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", _plainSerDe.serializeString(headerParameter)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .call( errorParameterSerializationChannel, @@ -1625,6 +1849,14 @@ public ListenableFuture> aliasLongEndpoint( _request.putQueryParams( "input", Objects.toString(input.get().get())); } + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .call(aliasLongEndpointChannel, _request.build(), aliasLongEndpointDeserializer); } @@ -1648,6 +1880,14 @@ public ListenableFuture complexQueryParameters( for (int intsElement : ints) { _request.putQueryParams("ints", _plainSerDe.serializeInteger(intsElement)); } + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .call(complexQueryParametersChannel, _request.build(), complexQueryParametersDeserializer); } @@ -1657,6 +1897,14 @@ public ListenableFuture receiveListOfOptionals(AuthHeader authHeader, List Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(receiveListOfOptionalsSerializer.serialize(value)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .call(receiveListOfOptionalsChannel, _request.build(), receiveListOfOptionalsDeserializer); } @@ -1666,6 +1914,14 @@ public ListenableFuture receiveSetOfOptionals(AuthHeader authHeader, Set receiveListOfStrings(AuthHeader authHeader, List optionalString(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .callBlocking(optionalStringChannel, _request.build(), optionalStringDeserializer); } @@ -1405,6 +1474,14 @@ public Optional optionalString(AuthHeader authHeader) { public Optional optionalEmpty(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .callBlocking(optionalEmptyChannel, _request.build(), optionalEmptyDeserializer); } @@ -1413,6 +1490,14 @@ public Optional optionalEmpty(AuthHeader authHeader) { public OffsetDateTime datetime(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().callBlocking(datetimeChannel, _request.build(), datetimeDeserializer); } @@ -1420,6 +1505,14 @@ public OffsetDateTime datetime(AuthHeader authHeader) { public InputStream binary(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .callBlocking( binaryChannel, @@ -1432,6 +1525,14 @@ public String path(AuthHeader authHeader, String param) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("param", _plainSerDe.serializeString(param)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().callBlocking(pathChannel, _request.build(), pathDeserializer); } @@ -1440,6 +1541,14 @@ public long externalLongPath(AuthHeader authHeader, long param) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("param", Objects.toString(param)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .callBlocking(externalLongPathChannel, _request.build(), externalLongPathDeserializer); } @@ -1451,6 +1560,14 @@ public Optional optionalExternalLongQuery(AuthHeader authHeader, Optional< if (param.isPresent()) { _request.putQueryParams("param", Objects.toString(param.get())); } + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .callBlocking( optionalExternalLongQueryChannel, @@ -1463,6 +1580,14 @@ public StringAliasExample notNullBody(AuthHeader authHeader, StringAliasExample Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(notNullBodySerializer.serialize(notNullBody)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().callBlocking(notNullBodyChannel, _request.build(), notNullBodyDeserializer); } @@ -1471,6 +1596,14 @@ public StringAliasExample aliasOne(AuthHeader authHeader, StringAliasExample que Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putQueryParams("queryParamName", _plainSerDe.serializeString(queryParamName.get())); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().callBlocking(aliasOneChannel, _request.build(), aliasOneDeserializer); } @@ -1484,6 +1617,14 @@ public StringAliasExample optionalAliasOne( "queryParamName", _plainSerDe.serializeString(queryParamName.get().get())); } + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .callBlocking(optionalAliasOneChannel, _request.build(), optionalAliasOneDeserializer); } @@ -1495,6 +1636,14 @@ public NestedStringAliasExample aliasTwo(AuthHeader authHeader, NestedStringAlia _request.putQueryParams( "queryParamName", _plainSerDe.serializeString(queryParamName.get().get())); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().callBlocking(aliasTwoChannel, _request.build(), aliasTwoDeserializer); } @@ -1504,6 +1653,14 @@ public allexamples.com.palantir.product.StringAliasExample notNullBodyExternalIm Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(notNullBodyExternalImportSerializer.serialize(notNullBody)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .callBlocking( notNullBodyExternalImportChannel, @@ -1517,6 +1674,14 @@ public Optional optionalBod Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(optionalBodyExternalImportSerializer.serialize(body)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .callBlocking( optionalBodyExternalImportChannel, @@ -1532,6 +1697,14 @@ public Optional optionalQue if (query.isPresent()) { _request.putQueryParams("query", Objects.toString(query.get())); } + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .callBlocking( optionalQueryExternalImportChannel, @@ -1543,6 +1716,14 @@ public Optional optionalQue public void noReturn(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } _runtime.clients().callBlocking(noReturnChannel, _request.build(), noReturnDeserializer); } @@ -1551,6 +1732,14 @@ public SimpleEnum enumQuery(AuthHeader authHeader, SimpleEnum queryParamName) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putQueryParams("queryParamName", Objects.toString(queryParamName)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().callBlocking(enumQueryChannel, _request.build(), enumQueryDeserializer); } @@ -1561,6 +1750,14 @@ public List enumListQuery(AuthHeader authHeader, List qu for (SimpleEnum queryParamNameElement : queryParamName) { _request.putQueryParams("queryParamName", Objects.toString(queryParamNameElement)); } + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .callBlocking(enumListQueryChannel, _request.build(), enumListQueryDeserializer); } @@ -1572,6 +1769,14 @@ public Optional optionalEnumQuery(AuthHeader authHeader, Optional aliasLongEndpoint(AuthHeader authHeader, Optional> Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(receiveListOfOptionalsSerializer.serialize(value)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } _runtime.clients() .callBlocking( receiveListOfOptionalsChannel, _request.build(), receiveListOfOptionalsDeserializer); @@ -1658,6 +1911,14 @@ public void receiveSetOfOptionals(AuthHeader authHeader, Set> v Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(receiveSetOfOptionalsSerializer.serialize(value)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } _runtime.clients() .callBlocking( receiveSetOfOptionalsChannel, _request.build(), receiveSetOfOptionalsDeserializer); @@ -1668,6 +1929,14 @@ public void receiveListOfStrings(AuthHeader authHeader, List value) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(receiveListOfStringsSerializer.serialize(value)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } _runtime.clients() .callBlocking(receiveListOfStringsChannel, _request.build(), receiveListOfStringsDeserializer); } diff --git a/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceAsync.java b/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceAsync.java index 6f3b550c2..a7bf63f85 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceAsync.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceAsync.java @@ -45,6 +45,14 @@ static CookieServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Con public ListenableFuture eatCookies(BearerToken token) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Cookie", "PALANTIR_TOKEN=" + _plainSerDe.serializeBearerToken(token)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().call(eatCookiesChannel, _request.build(), eatCookiesDeserializer); } diff --git a/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceBlocking.java b/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceBlocking.java index 8c0fc9e04..50dd62b3a 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceBlocking.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceBlocking.java @@ -44,6 +44,14 @@ static CookieServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, public void eatCookies(BearerToken token) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Cookie", "PALANTIR_TOKEN=" + _plainSerDe.serializeBearerToken(token)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } _runtime.clients().callBlocking(eatCookiesChannel, _request.build(), eatCookiesDeserializer); } diff --git a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/another/EndpointSpecificErrors.java b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/another/EndpointSpecificErrors.java index e59dc9bdd..6ebc7dc34 100644 --- a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/another/EndpointSpecificErrors.java +++ b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/another/EndpointSpecificErrors.java @@ -8,7 +8,9 @@ import com.palantir.conjure.java.api.errors.SerializableError; import com.palantir.logsafe.Preconditions; import com.palantir.logsafe.Safe; +import java.util.Map; import javax.annotation.processing.Generated; +import org.jspecify.annotations.Nullable; @Generated("com.palantir.conjure.java.types.ErrorGenerator") public final class EndpointSpecificErrors { @@ -28,20 +30,27 @@ public static record DifferentPackageParameters() {} public static final class DifferentPackageSerializableError extends AbstractSerializableError { + @Nullable + private final Map legacyParameters; + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) DifferentPackageSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") DifferentPackageParameters parameters) { + @JsonProperty("parameters") DifferentPackageParameters parameters, + @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { super(errorCode, errorName, errorInstanceId, parameters); + this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder() - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()); + SerializableError.Builder builder = SerializableError.builder(); + if (legacyParameters != null) { + builder.putAllParameters(legacyParameters); + } else { + } + builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); return builder.build(); } } @@ -49,12 +58,9 @@ public SerializableError toSerializableError() { public static final class DifferentPackageException extends RemoteException { private DifferentPackageSerializableError error; - private int status; - public DifferentPackageException(DifferentPackageSerializableError error, int status) { super(error.toSerializableError(), status); this.error = error; - this.status = status; } public DifferentPackageSerializableError error() { diff --git a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ConjureErrors.java b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ConjureErrors.java index d01fa290a..d34a7fcc8 100644 --- a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ConjureErrors.java +++ b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ConjureErrors.java @@ -8,8 +8,10 @@ import com.palantir.conjure.java.api.errors.SerializableError; import com.palantir.logsafe.Preconditions; import com.palantir.logsafe.Safe; +import java.util.Map; import java.util.Objects; import javax.annotation.processing.Generated; +import org.jspecify.annotations.Nullable; @Generated("com.palantir.conjure.java.types.ErrorGenerator") public final class ConjureErrors { @@ -32,22 +34,30 @@ public static record ConflictingCauseSafeArgErrParameters( public static final class ConflictingCauseSafeArgErrSerializableError extends AbstractSerializableError { + @Nullable + private final Map legacyParameters; + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) ConflictingCauseSafeArgErrSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") ConflictingCauseSafeArgErrParameters parameters) { + @JsonProperty("parameters") ConflictingCauseSafeArgErrParameters parameters, + @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { super(errorCode, errorName, errorInstanceId, parameters); + this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder() - .putParameters("cause", Objects.toString(parameters().cause_())) - .putParameters("shouldThrow", Objects.toString(parameters().shouldThrow_())) - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()); + SerializableError.Builder builder = SerializableError.builder(); + if (legacyParameters != null) { + builder.putAllParameters(legacyParameters); + } else { + builder.putParameters("cause", Objects.toString(parameters().cause_())) + .putParameters( + "shouldThrow", Objects.toString(parameters().shouldThrow_())); + } + builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); return builder.build(); } } @@ -55,12 +65,9 @@ public SerializableError toSerializableError() { public static final class ConflictingCauseSafeArgErrException extends RemoteException { private ConflictingCauseSafeArgErrSerializableError error; - private int status; - public ConflictingCauseSafeArgErrException(ConflictingCauseSafeArgErrSerializableError error, int status) { super(error.toSerializableError(), status); this.error = error; - this.status = status; } public ConflictingCauseSafeArgErrSerializableError error() { diff --git a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/EndpointSpecificErrors.java b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/EndpointSpecificErrors.java index 96446fdce..f7e41fb0c 100644 --- a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/EndpointSpecificErrors.java +++ b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/EndpointSpecificErrors.java @@ -9,8 +9,10 @@ import com.palantir.logsafe.Preconditions; import com.palantir.logsafe.Safe; import com.palantir.logsafe.Unsafe; +import java.util.Map; import java.util.Objects; import javax.annotation.processing.Generated; +import org.jspecify.annotations.Nullable; @Generated("com.palantir.conjure.java.types.ErrorGenerator") public final class EndpointSpecificErrors { @@ -31,22 +33,29 @@ public static record EndpointErrorParameters( public static final class EndpointErrorSerializableError extends AbstractSerializableError { + @Nullable + private final Map legacyParameters; + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) EndpointErrorSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") EndpointErrorParameters parameters) { + @JsonProperty("parameters") EndpointErrorParameters parameters, + @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { super(errorCode, errorName, errorInstanceId, parameters); + this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder() - .putParameters("typeName", Objects.toString(parameters().typeName())) - .putParameters("typeDef", Objects.toString(parameters().typeDef())) - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()); + SerializableError.Builder builder = SerializableError.builder(); + if (legacyParameters != null) { + builder.putAllParameters(legacyParameters); + } else { + builder.putParameters("typeName", Objects.toString(parameters().typeName())) + .putParameters("typeDef", Objects.toString(parameters().typeDef())); + } + builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); return builder.build(); } } @@ -54,12 +63,9 @@ public SerializableError toSerializableError() { public static final class EndpointErrorException extends RemoteException { private EndpointErrorSerializableError error; - private int status; - public EndpointErrorException(EndpointErrorSerializableError error, int status) { super(error.toSerializableError(), status); this.error = error; - this.status = status; } public EndpointErrorSerializableError error() { diff --git a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/EndpointSpecificTwoErrors.java b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/EndpointSpecificTwoErrors.java index c25be2c9a..c3bf8ad03 100644 --- a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/EndpointSpecificTwoErrors.java +++ b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/EndpointSpecificTwoErrors.java @@ -8,7 +8,9 @@ import com.palantir.conjure.java.api.errors.SerializableError; import com.palantir.logsafe.Preconditions; import com.palantir.logsafe.Safe; +import java.util.Map; import javax.annotation.processing.Generated; +import org.jspecify.annotations.Nullable; @Generated("com.palantir.conjure.java.types.ErrorGenerator") public final class EndpointSpecificTwoErrors { @@ -28,20 +30,27 @@ public static record DifferentNamespaceParameters() {} public static final class DifferentNamespaceSerializableError extends AbstractSerializableError { + @Nullable + private final Map legacyParameters; + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) DifferentNamespaceSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") DifferentNamespaceParameters parameters) { + @JsonProperty("parameters") DifferentNamespaceParameters parameters, + @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { super(errorCode, errorName, errorInstanceId, parameters); + this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder() - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()); + SerializableError.Builder builder = SerializableError.builder(); + if (legacyParameters != null) { + builder.putAllParameters(legacyParameters); + } else { + } + builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); return builder.build(); } } @@ -49,12 +58,9 @@ public SerializableError toSerializableError() { public static final class DifferentNamespaceException extends RemoteException { private DifferentNamespaceSerializableError error; - private int status; - public DifferentNamespaceException(DifferentNamespaceSerializableError error, int status) { super(error.toSerializableError(), status); this.error = error; - this.status = status; } public DifferentNamespaceSerializableError error() { diff --git a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorServiceAsync.java b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorServiceAsync.java index 06c57b75c..ad3ed5ea0 100644 --- a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorServiceAsync.java +++ b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorServiceAsync.java @@ -189,6 +189,14 @@ public ListenableFuture testBasicError( Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(testBasicErrorSerializer.serialize(shouldThrowError)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().call(testBasicErrorChannel, _request.build(), testBasicErrorDeserializer); } @@ -198,6 +206,14 @@ public ListenableFuture testImportedError( Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(testImportedErrorSerializer.serialize(shouldThrowError)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .call(testImportedErrorChannel, _request.build(), testImportedErrorDeserializer); } @@ -208,6 +224,14 @@ public ListenableFuture testMultipleError Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(testMultipleErrorsAndPackagesSerializer.serialize(errorToThrow)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .call( testMultipleErrorsAndPackagesChannel, @@ -221,6 +245,14 @@ public ListenableFuture testEmptyBody( Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(testEmptyBodySerializer.serialize(shouldThrowError)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().call(testEmptyBodyChannel, _request.build(), testEmptyBodyDeserializer); } @@ -229,6 +261,14 @@ public ListenableFuture testBinary(AuthHeader authHeader, bo Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(testBinarySerializer.serialize(shouldThrowError)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().call(testBinaryChannel, _request.build(), testBinaryDeserializer); } @@ -238,6 +278,14 @@ public ListenableFuture testOptionalBinary( Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(testOptionalBinarySerializer.serialize(mode)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .call(testOptionalBinaryChannel, _request.build(), testOptionalBinaryDeserializer); } diff --git a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorServiceBlocking.java b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorServiceBlocking.java index 056d33312..dd1d6c4ff 100644 --- a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorServiceBlocking.java +++ b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorServiceBlocking.java @@ -186,6 +186,14 @@ public TestBasicErrorResponse testBasicError(AuthHeader authHeader, boolean shou Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(testBasicErrorSerializer.serialize(shouldThrowError)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .callBlocking(testBasicErrorChannel, _request.build(), testBasicErrorDeserializer); } @@ -195,6 +203,14 @@ public TestImportedErrorResponse testImportedError(AuthHeader authHeader, boolea Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(testImportedErrorSerializer.serialize(shouldThrowError)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .callBlocking(testImportedErrorChannel, _request.build(), testImportedErrorDeserializer); } @@ -205,6 +221,14 @@ public TestMultipleErrorsAndPackagesResponse testMultipleErrorsAndPackages( Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(testMultipleErrorsAndPackagesSerializer.serialize(errorToThrow)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .callBlocking( testMultipleErrorsAndPackagesChannel, @@ -217,6 +241,14 @@ public TestEmptyBodyResponse testEmptyBody(AuthHeader authHeader, boolean should Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(testEmptyBodySerializer.serialize(shouldThrowError)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .callBlocking(testEmptyBodyChannel, _request.build(), testEmptyBodyDeserializer); } @@ -226,6 +258,14 @@ public TestBinaryResponse testBinary(AuthHeader authHeader, boolean shouldThrowE Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(testBinarySerializer.serialize(shouldThrowError)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().callBlocking(testBinaryChannel, _request.build(), testBinaryDeserializer); } @@ -235,6 +275,14 @@ public TestOptionalBinaryResponse testOptionalBinary( Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(testOptionalBinarySerializer.serialize(mode)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .callBlocking(testOptionalBinaryChannel, _request.build(), testOptionalBinaryDeserializer); } diff --git a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/TestErrors.java b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/TestErrors.java index 0238affd0..bfe68c7bf 100644 --- a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/TestErrors.java +++ b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/TestErrors.java @@ -12,6 +12,7 @@ import java.util.Map; import java.util.Objects; import javax.annotation.processing.Generated; +import org.jspecify.annotations.Nullable; @Generated("com.palantir.conjure.java.types.ErrorGenerator") public final class TestErrors { @@ -53,65 +54,85 @@ public static record NotFoundParameters(@JsonProperty("resource") @Safe String r public static final class ComplicatedParametersSerializableError extends AbstractSerializableError { + @Nullable + private final Map legacyParameters; + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) ComplicatedParametersSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") ComplicatedParametersParameters parameters) { + @JsonProperty("parameters") ComplicatedParametersParameters parameters, + @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { super(errorCode, errorName, errorInstanceId, parameters); + this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder() - .putParameters( - "complicatedObjectMap", - Objects.toString(parameters().complicatedObjectMap())) - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()); + SerializableError.Builder builder = SerializableError.builder(); + if (legacyParameters != null) { + builder.putAllParameters(legacyParameters); + } else { + builder.putParameters( + "complicatedObjectMap", Objects.toString(parameters().complicatedObjectMap())); + } + builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); return builder.build(); } } public static final class InvalidArgumentSerializableError extends AbstractSerializableError { + @Nullable + private final Map legacyParameters; + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) InvalidArgumentSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") InvalidArgumentParameters parameters) { + @JsonProperty("parameters") InvalidArgumentParameters parameters, + @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { super(errorCode, errorName, errorInstanceId, parameters); + this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder() - .putParameters("field", Objects.toString(parameters().field())) - .putParameters("value", Objects.toString(parameters().value())) - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()); + SerializableError.Builder builder = SerializableError.builder(); + if (legacyParameters != null) { + builder.putAllParameters(legacyParameters); + } else { + builder.putParameters("field", Objects.toString(parameters().field())) + .putParameters("value", Objects.toString(parameters().value())); + } + builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); return builder.build(); } } public static final class NotFoundSerializableError extends AbstractSerializableError { + @Nullable + private final Map legacyParameters; + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) NotFoundSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") NotFoundParameters parameters) { + @JsonProperty("parameters") NotFoundParameters parameters, + @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { super(errorCode, errorName, errorInstanceId, parameters); + this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder() - .putParameters("resource", Objects.toString(parameters().resource())) - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()); + SerializableError.Builder builder = SerializableError.builder(); + if (legacyParameters != null) { + builder.putAllParameters(legacyParameters); + } else { + builder.putParameters("resource", Objects.toString(parameters().resource())); + } + builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); return builder.build(); } } @@ -119,12 +140,9 @@ public SerializableError toSerializableError() { public static final class ComplicatedParametersException extends RemoteException { private ComplicatedParametersSerializableError error; - private int status; - public ComplicatedParametersException(ComplicatedParametersSerializableError error, int status) { super(error.toSerializableError(), status); this.error = error; - this.status = status; } public ComplicatedParametersSerializableError error() { @@ -135,12 +153,9 @@ public ComplicatedParametersSerializableError error() { public static final class InvalidArgumentException extends RemoteException { private InvalidArgumentSerializableError error; - private int status; - public InvalidArgumentException(InvalidArgumentSerializableError error, int status) { super(error.toSerializableError(), status); this.error = error; - this.status = status; } public InvalidArgumentSerializableError error() { @@ -151,12 +166,9 @@ public InvalidArgumentSerializableError error() { public static final class NotFoundException extends RemoteException { private NotFoundSerializableError error; - private int status; - public NotFoundException(NotFoundSerializableError error, int status) { super(error.toSerializableError(), status); this.error = error; - this.status = status; } public NotFoundSerializableError error() { diff --git a/conjure-java-core/src/integrationInput/java/errors/com/palantir/another/ConjureErrors.java b/conjure-java-core/src/integrationInput/java/errors/com/palantir/another/ConjureErrors.java index 22650c204..9be0b0828 100644 --- a/conjure-java-core/src/integrationInput/java/errors/com/palantir/another/ConjureErrors.java +++ b/conjure-java-core/src/integrationInput/java/errors/com/palantir/another/ConjureErrors.java @@ -9,6 +9,7 @@ import com.palantir.conjure.java.api.errors.ServiceException; import com.palantir.logsafe.Preconditions; import com.palantir.logsafe.Safe; +import java.util.Map; import javax.annotation.Nullable; import javax.annotation.processing.Generated; import org.jetbrains.annotations.Contract; @@ -51,20 +52,28 @@ public static record DifferentPackageErrParameters() {} public static final class DifferentPackageErrSerializableError extends AbstractSerializableError { + @org.jspecify.annotations.Nullable + private final Map legacyParameters; + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) DifferentPackageErrSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") DifferentPackageErrParameters parameters) { + @JsonProperty("parameters") DifferentPackageErrParameters parameters, + @JsonProperty("legacyParameters") @org.jspecify.annotations.Nullable + Map legacyParameters) { super(errorCode, errorName, errorInstanceId, parameters); + this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder() - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()); + SerializableError.Builder builder = SerializableError.builder(); + if (legacyParameters != null) { + builder.putAllParameters(legacyParameters); + } else { + } + builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); return builder.build(); } } @@ -72,12 +81,9 @@ public SerializableError toSerializableError() { public static final class DifferentPackageErrException extends RemoteException { private DifferentPackageErrSerializableError error; - private int status; - public DifferentPackageErrException(DifferentPackageErrSerializableError error, int status) { super(error.toSerializableError(), status); this.error = error; - this.status = status; } public DifferentPackageErrSerializableError error() { diff --git a/conjure-java-core/src/integrationInput/java/errors/com/palantir/another/ConjureJavaOtherErrors.java b/conjure-java-core/src/integrationInput/java/errors/com/palantir/another/ConjureJavaOtherErrors.java index 49f9e4398..223104000 100644 --- a/conjure-java-core/src/integrationInput/java/errors/com/palantir/another/ConjureJavaOtherErrors.java +++ b/conjure-java-core/src/integrationInput/java/errors/com/palantir/another/ConjureJavaOtherErrors.java @@ -9,6 +9,7 @@ import com.palantir.conjure.java.api.errors.ServiceException; import com.palantir.logsafe.Preconditions; import com.palantir.logsafe.Safe; +import java.util.Map; import javax.annotation.Nullable; import javax.annotation.processing.Generated; import org.jetbrains.annotations.Contract; @@ -51,20 +52,28 @@ public static record JavaCompilationFailedParameters() {} public static final class JavaCompilationFailedSerializableError extends AbstractSerializableError { + @org.jspecify.annotations.Nullable + private final Map legacyParameters; + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) JavaCompilationFailedSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") JavaCompilationFailedParameters parameters) { + @JsonProperty("parameters") JavaCompilationFailedParameters parameters, + @JsonProperty("legacyParameters") @org.jspecify.annotations.Nullable + Map legacyParameters) { super(errorCode, errorName, errorInstanceId, parameters); + this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder() - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()); + SerializableError.Builder builder = SerializableError.builder(); + if (legacyParameters != null) { + builder.putAllParameters(legacyParameters); + } else { + } + builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); return builder.build(); } } @@ -72,12 +81,9 @@ public SerializableError toSerializableError() { public static final class JavaCompilationFailedException extends RemoteException { private JavaCompilationFailedSerializableError error; - private int status; - public JavaCompilationFailedException(JavaCompilationFailedSerializableError error, int status) { super(error.toSerializableError(), status); this.error = error; - this.status = status; } public JavaCompilationFailedSerializableError error() { diff --git a/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureErrors.java b/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureErrors.java index b1290939c..8c5e24da0 100644 --- a/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureErrors.java +++ b/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureErrors.java @@ -12,6 +12,7 @@ import com.palantir.logsafe.SafeArg; import com.palantir.logsafe.Unsafe; import com.palantir.logsafe.UnsafeArg; +import java.util.Map; import java.util.Objects; import javax.annotation.Nullable; import javax.annotation.processing.Generated; @@ -373,135 +374,187 @@ public static record InvalidTypeDefinitionParameters( public static final class ConflictingCauseSafeArgSerializableError extends AbstractSerializableError { + @org.jspecify.annotations.Nullable + private final Map legacyParameters; + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) ConflictingCauseSafeArgSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") ConflictingCauseSafeArgParameters parameters) { + @JsonProperty("parameters") ConflictingCauseSafeArgParameters parameters, + @JsonProperty("legacyParameters") @org.jspecify.annotations.Nullable + Map legacyParameters) { super(errorCode, errorName, errorInstanceId, parameters); + this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder() - .putParameters("cause", Objects.toString(parameters().cause_())) - .putParameters("shouldThrow", Objects.toString(parameters().shouldThrow_())) - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()); + SerializableError.Builder builder = SerializableError.builder(); + if (legacyParameters != null) { + builder.putAllParameters(legacyParameters); + } else { + builder.putParameters("cause", Objects.toString(parameters().cause_())) + .putParameters( + "shouldThrow", Objects.toString(parameters().shouldThrow_())); + } + builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); return builder.build(); } } public static final class ConflictingCauseUnsafeArgSerializableError extends AbstractSerializableError { + @org.jspecify.annotations.Nullable + private final Map legacyParameters; + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) ConflictingCauseUnsafeArgSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") ConflictingCauseUnsafeArgParameters parameters) { + @JsonProperty("parameters") ConflictingCauseUnsafeArgParameters parameters, + @JsonProperty("legacyParameters") @org.jspecify.annotations.Nullable + Map legacyParameters) { super(errorCode, errorName, errorInstanceId, parameters); + this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder() - .putParameters("cause", Objects.toString(parameters().cause_())) - .putParameters("shouldThrow", Objects.toString(parameters().shouldThrow_())) - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()); + SerializableError.Builder builder = SerializableError.builder(); + if (legacyParameters != null) { + builder.putAllParameters(legacyParameters); + } else { + builder.putParameters("cause", Objects.toString(parameters().cause_())) + .putParameters( + "shouldThrow", Objects.toString(parameters().shouldThrow_())); + } + builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); return builder.build(); } } public static final class ErrorWithComplexArgsSerializableError extends AbstractSerializableError { + @org.jspecify.annotations.Nullable + private final Map legacyParameters; + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) ErrorWithComplexArgsSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") ErrorWithComplexArgsParameters parameters) { + @JsonProperty("parameters") ErrorWithComplexArgsParameters parameters, + @JsonProperty("legacyParameters") @org.jspecify.annotations.Nullable + Map legacyParameters) { super(errorCode, errorName, errorInstanceId, parameters); + this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder() - .putParameters( - "primitiveExample", Objects.toString(parameters().primitiveExample())) - .putParameters( - "collectionExample", Objects.toString(parameters().collectionExample())) - .putParameters( - "nestedCollectionExample", - Objects.toString(parameters().nestedCollectionExample())) - .putParameters( - "optionalExample", Objects.toString(parameters().optionalExample())) - .putParameters( - "objectReference", Objects.toString(parameters().objectReference())) - .putParameters("unionExample", Objects.toString(parameters().unionExample())) - .putParameters("enumExample", Objects.toString(parameters().enumExample())) - .putParameters("stringAlias", Objects.toString(parameters().stringAlias())) - .putParameters( - "optionalAlias", Objects.toString(parameters().optionalAlias())) - .putParameters( - "collectionAlias", Objects.toString(parameters().collectionAlias())) - .putParameters("nestedAlias", Objects.toString(parameters().nestedAlias())) - .putParameters( - "externalExample", Objects.toString(parameters().externalExample())) - .putParameters("anyExample", Objects.toString(parameters().anyExample())) - .putParameters("emptyObject", Objects.toString(parameters().emptyObject())) - .putParameters( - "complexExample", Objects.toString(parameters().complexExample())) - .putParameters( - "safetyExample", Objects.toString(parameters().safetyExample())) - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()); + SerializableError.Builder builder = SerializableError.builder(); + if (legacyParameters != null) { + builder.putAllParameters(legacyParameters); + } else { + builder.putParameters( + "primitiveExample", + Objects.toString(parameters().primitiveExample())) + .putParameters( + "collectionExample", + Objects.toString(parameters().collectionExample())) + .putParameters( + "nestedCollectionExample", + Objects.toString(parameters().nestedCollectionExample())) + .putParameters( + "optionalExample", Objects.toString(parameters().optionalExample())) + .putParameters( + "objectReference", Objects.toString(parameters().objectReference())) + .putParameters( + "unionExample", Objects.toString(parameters().unionExample())) + .putParameters( + "enumExample", Objects.toString(parameters().enumExample())) + .putParameters( + "stringAlias", Objects.toString(parameters().stringAlias())) + .putParameters( + "optionalAlias", Objects.toString(parameters().optionalAlias())) + .putParameters( + "collectionAlias", Objects.toString(parameters().collectionAlias())) + .putParameters( + "nestedAlias", Objects.toString(parameters().nestedAlias())) + .putParameters( + "externalExample", Objects.toString(parameters().externalExample())) + .putParameters( + "anyExample", Objects.toString(parameters().anyExample())) + .putParameters( + "emptyObject", Objects.toString(parameters().emptyObject())) + .putParameters( + "complexExample", Objects.toString(parameters().complexExample())) + .putParameters( + "safetyExample", Objects.toString(parameters().safetyExample())); + } + builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); return builder.build(); } } public static final class InvalidServiceDefinitionSerializableError extends AbstractSerializableError { + @org.jspecify.annotations.Nullable + private final Map legacyParameters; + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) InvalidServiceDefinitionSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") InvalidServiceDefinitionParameters parameters) { + @JsonProperty("parameters") InvalidServiceDefinitionParameters parameters, + @JsonProperty("legacyParameters") @org.jspecify.annotations.Nullable + Map legacyParameters) { super(errorCode, errorName, errorInstanceId, parameters); + this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder() - .putParameters("serviceName", Objects.toString(parameters().serviceName())) - .putParameters("serviceDef", Objects.toString(parameters().serviceDef())) - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()); + SerializableError.Builder builder = SerializableError.builder(); + if (legacyParameters != null) { + builder.putAllParameters(legacyParameters); + } else { + builder.putParameters( + "serviceName", Objects.toString(parameters().serviceName())) + .putParameters( + "serviceDef", Objects.toString(parameters().serviceDef())); + } + builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); return builder.build(); } } public static final class InvalidTypeDefinitionSerializableError extends AbstractSerializableError { + @org.jspecify.annotations.Nullable + private final Map legacyParameters; + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) InvalidTypeDefinitionSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") InvalidTypeDefinitionParameters parameters) { + @JsonProperty("parameters") InvalidTypeDefinitionParameters parameters, + @JsonProperty("legacyParameters") @org.jspecify.annotations.Nullable + Map legacyParameters) { super(errorCode, errorName, errorInstanceId, parameters); + this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder() - .putParameters("typeName", Objects.toString(parameters().typeName())) - .putParameters("typeDef", Objects.toString(parameters().typeDef())) - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()); + SerializableError.Builder builder = SerializableError.builder(); + if (legacyParameters != null) { + builder.putAllParameters(legacyParameters); + } else { + builder.putParameters("typeName", Objects.toString(parameters().typeName())) + .putParameters("typeDef", Objects.toString(parameters().typeDef())); + } + builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); return builder.build(); } } @@ -509,12 +562,9 @@ public SerializableError toSerializableError() { public static final class ConflictingCauseSafeArgException extends RemoteException { private ConflictingCauseSafeArgSerializableError error; - private int status; - public ConflictingCauseSafeArgException(ConflictingCauseSafeArgSerializableError error, int status) { super(error.toSerializableError(), status); this.error = error; - this.status = status; } public ConflictingCauseSafeArgSerializableError error() { @@ -525,12 +575,9 @@ public ConflictingCauseSafeArgSerializableError error() { public static final class ConflictingCauseUnsafeArgException extends RemoteException { private ConflictingCauseUnsafeArgSerializableError error; - private int status; - public ConflictingCauseUnsafeArgException(ConflictingCauseUnsafeArgSerializableError error, int status) { super(error.toSerializableError(), status); this.error = error; - this.status = status; } public ConflictingCauseUnsafeArgSerializableError error() { @@ -541,12 +588,9 @@ public ConflictingCauseUnsafeArgSerializableError error() { public static final class ErrorWithComplexArgsException extends RemoteException { private ErrorWithComplexArgsSerializableError error; - private int status; - public ErrorWithComplexArgsException(ErrorWithComplexArgsSerializableError error, int status) { super(error.toSerializableError(), status); this.error = error; - this.status = status; } public ErrorWithComplexArgsSerializableError error() { @@ -557,12 +601,9 @@ public ErrorWithComplexArgsSerializableError error() { public static final class InvalidServiceDefinitionException extends RemoteException { private InvalidServiceDefinitionSerializableError error; - private int status; - public InvalidServiceDefinitionException(InvalidServiceDefinitionSerializableError error, int status) { super(error.toSerializableError(), status); this.error = error; - this.status = status; } public InvalidServiceDefinitionSerializableError error() { @@ -573,12 +614,9 @@ public InvalidServiceDefinitionSerializableError error() { public static final class InvalidTypeDefinitionException extends RemoteException { private InvalidTypeDefinitionSerializableError error; - private int status; - public InvalidTypeDefinitionException(InvalidTypeDefinitionSerializableError error, int status) { super(error.toSerializableError(), status); this.error = error; - this.status = status; } public InvalidTypeDefinitionSerializableError error() { diff --git a/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureJavaErrors.java b/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureJavaErrors.java index 0ad353c73..655b73304 100644 --- a/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureJavaErrors.java +++ b/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureJavaErrors.java @@ -9,6 +9,7 @@ import com.palantir.conjure.java.api.errors.ServiceException; import com.palantir.logsafe.Preconditions; import com.palantir.logsafe.Safe; +import java.util.Map; import javax.annotation.Nullable; import javax.annotation.processing.Generated; import org.jetbrains.annotations.Contract; @@ -51,20 +52,28 @@ public static record JavaCompilationFailedParameters() {} public static final class JavaCompilationFailedSerializableError extends AbstractSerializableError { + @org.jspecify.annotations.Nullable + private final Map legacyParameters; + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) JavaCompilationFailedSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") JavaCompilationFailedParameters parameters) { + @JsonProperty("parameters") JavaCompilationFailedParameters parameters, + @JsonProperty("legacyParameters") @org.jspecify.annotations.Nullable + Map legacyParameters) { super(errorCode, errorName, errorInstanceId, parameters); + this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder() - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()); + SerializableError.Builder builder = SerializableError.builder(); + if (legacyParameters != null) { + builder.putAllParameters(legacyParameters); + } else { + } + builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); return builder.build(); } } @@ -72,12 +81,9 @@ public SerializableError toSerializableError() { public static final class JavaCompilationFailedException extends RemoteException { private JavaCompilationFailedSerializableError error; - private int status; - public JavaCompilationFailedException(JavaCompilationFailedSerializableError error, int status) { super(error.toSerializableError(), status); this.error = error; - this.status = status; } public JavaCompilationFailedSerializableError error() { diff --git a/conjure-java-core/src/integrationInput/java/excludeasyncinterfaces/com/palantir/another/TestServiceBlocking.java b/conjure-java-core/src/integrationInput/java/excludeasyncinterfaces/com/palantir/another/TestServiceBlocking.java index df308a663..1268cb4ed 100644 --- a/conjure-java-core/src/integrationInput/java/excludeasyncinterfaces/com/palantir/another/TestServiceBlocking.java +++ b/conjure-java-core/src/integrationInput/java/excludeasyncinterfaces/com/palantir/another/TestServiceBlocking.java @@ -322,6 +322,14 @@ static TestServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Co public Map getFileSystems(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .callBlocking(getFileSystemsChannel, _request.build(), getFileSystemsDeserializer); } @@ -332,6 +340,14 @@ public Dataset createDataset(AuthHeader authHeader, String testHeaderArg, Create _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(createDatasetSerializer.serialize(request)); _request.putHeaderParams("Test-Header", _plainSerDe.serializeString(testHeaderArg)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .callBlocking(createDatasetChannel, _request.build(), createDatasetDeserializer); } @@ -341,6 +357,14 @@ public Optional getDataset(AuthHeader authHeader, ResourceIdentifier da Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().callBlocking(getDatasetChannel, _request.build(), getDatasetDeserializer); } @@ -349,6 +373,14 @@ public InputStream getRawData(AuthHeader authHeader, ResourceIdentifier datasetR Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .callBlocking( getRawDataChannel, @@ -361,6 +393,14 @@ public InputStream getAliasedRawData(AuthHeader authHeader, ResourceIdentifier d Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .callBlocking( getAliasedRawDataChannel, @@ -373,6 +413,14 @@ public Optional maybeGetRawData(AuthHeader authHeader, ResourceIden Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .callBlocking( maybeGetRawDataChannel, @@ -385,6 +433,14 @@ public AliasedString getAliasedString(AuthHeader authHeader, ResourceIdentifier Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .callBlocking(getAliasedStringChannel, _request.build(), getAliasedStringDeserializer); } @@ -394,6 +450,14 @@ public void uploadRawData(AuthHeader authHeader, BinaryRequestBody input) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(_runtime.bodySerDe().serialize(input)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } _runtime.clients().callBlocking(uploadRawDataChannel, _request.build(), uploadRawDataDeserializer); } @@ -402,6 +466,14 @@ public void uploadAliasedRawData(AuthHeader authHeader, BinaryRequestBody input) Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(_runtime.bodySerDe().serialize(input)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } _runtime.clients() .callBlocking(uploadAliasedRawDataChannel, _request.build(), uploadAliasedRawDataDeserializer); } @@ -411,6 +483,14 @@ public Set getBranches(AuthHeader authHeader, ResourceIdentifier dataset Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().callBlocking(getBranchesChannel, _request.build(), getBranchesDeserializer); } @@ -420,6 +500,14 @@ public Set getBranchesDeprecated(AuthHeader authHeader, ResourceIdentifi Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .callBlocking( getBranchesDeprecatedChannel, _request.build(), getBranchesDeprecatedDeserializer); @@ -431,6 +519,14 @@ public Set getBranchesDeprecatedForRemoval(AuthHeader authHeader, Resour Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .callBlocking( getBranchesDeprecatedForRemovalChannel, @@ -444,6 +540,14 @@ public Optional resolveBranch(AuthHeader authHeader, ResourceIdentifier _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); _request.putPathParams("branch", _plainSerDe.serializeString(branch)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .callBlocking(resolveBranchChannel, _request.build(), resolveBranchDeserializer); } @@ -453,6 +557,14 @@ public Optional testParam(AuthHeader authHeader, ResourceIdentifier data Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().callBlocking(testParamChannel, _request.build(), testParamDeserializer); } @@ -479,6 +591,14 @@ public int testQueryParams( if (optionalEnd.isPresent()) { _request.putQueryParams("optionalEnd", _plainSerDe.serializeRid(optionalEnd.get())); } + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .callBlocking(testQueryParamsChannel, _request.build(), testQueryParamsDeserializer); } @@ -506,6 +626,14 @@ public void testNoResponseQueryParams( if (optionalEnd.isPresent()) { _request.putQueryParams("optionalEnd", _plainSerDe.serializeRid(optionalEnd.get())); } + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } _runtime.clients() .callBlocking( testNoResponseQueryParamsChannel, @@ -517,6 +645,14 @@ public void testNoResponseQueryParams( public boolean testBoolean(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().callBlocking(testBooleanChannel, _request.build(), testBooleanDeserializer); } @@ -524,6 +660,14 @@ public boolean testBoolean(AuthHeader authHeader) { public double testDouble(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().callBlocking(testDoubleChannel, _request.build(), testDoubleDeserializer); } @@ -531,6 +675,14 @@ public double testDouble(AuthHeader authHeader) { public int testInteger(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().callBlocking(testIntegerChannel, _request.build(), testIntegerDeserializer); } @@ -539,6 +691,14 @@ public Optional testPostOptional(AuthHeader authHeader, Optional Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(testPostOptionalSerializer.serialize(maybeString)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .callBlocking(testPostOptionalChannel, _request.build(), testPostOptionalDeserializer); } @@ -554,6 +714,14 @@ public void testOptionalIntegerAndDouble( if (maybeDouble.isPresent()) { _request.putQueryParams("maybeDouble", _plainSerDe.serializeDouble(maybeDouble.getAsDouble())); } + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } _runtime.clients() .callBlocking( testOptionalIntegerAndDoubleChannel, @@ -570,6 +738,14 @@ public void getForStrings( for (AliasedString stringsElement : strings) { _request.putQueryParams("strings", _plainSerDe.serializeString(stringsElement.get())); } + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } _runtime.clients().callBlocking(getForStringsChannel, _request.build(), getForStringsDeserializer); } diff --git a/conjure-java-core/src/integrationInput/java/externalfallbacktypes/com/palantir/product/external/ServiceUsingExternalTypesAsync.java b/conjure-java-core/src/integrationInput/java/externalfallbacktypes/com/palantir/product/external/ServiceUsingExternalTypesAsync.java index 218786792..bd47c7fbb 100644 --- a/conjure-java-core/src/integrationInput/java/externalfallbacktypes/com/palantir/product/external/ServiceUsingExternalTypesAsync.java +++ b/conjure-java-core/src/integrationInput/java/externalfallbacktypes/com/palantir/product/external/ServiceUsingExternalTypesAsync.java @@ -47,6 +47,14 @@ public ListenableFuture> external(String path, List Request.Builder _request = Request.builder(); _request.putPathParams("path", _plainSerDe.serializeString(path)); _request.body(externalSerializer.serialize(body)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().call(externalChannel, _request.build(), externalDeserializer); } diff --git a/conjure-java-core/src/integrationInput/java/externalfallbacktypes/com/palantir/product/external/ServiceUsingExternalTypesBlocking.java b/conjure-java-core/src/integrationInput/java/externalfallbacktypes/com/palantir/product/external/ServiceUsingExternalTypesBlocking.java index 67cef41c1..789f138f6 100644 --- a/conjure-java-core/src/integrationInput/java/externalfallbacktypes/com/palantir/product/external/ServiceUsingExternalTypesBlocking.java +++ b/conjure-java-core/src/integrationInput/java/externalfallbacktypes/com/palantir/product/external/ServiceUsingExternalTypesBlocking.java @@ -47,6 +47,14 @@ public Map external(String path, List body) { Request.Builder _request = Request.builder(); _request.putPathParams("path", _plainSerDe.serializeString(path)); _request.body(externalSerializer.serialize(body)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().callBlocking(externalChannel, _request.build(), externalDeserializer); } diff --git a/conjure-java-core/src/integrationInput/java/servicevanilla/com/palantir/another/TestServiceAsync.java b/conjure-java-core/src/integrationInput/java/servicevanilla/com/palantir/another/TestServiceAsync.java index 84376eb0a..859ebb1b9 100644 --- a/conjure-java-core/src/integrationInput/java/servicevanilla/com/palantir/another/TestServiceAsync.java +++ b/conjure-java-core/src/integrationInput/java/servicevanilla/com/palantir/another/TestServiceAsync.java @@ -325,6 +325,14 @@ static TestServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conju public ListenableFuture> getFileSystems(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().call(getFileSystemsChannel, _request.build(), getFileSystemsDeserializer); } @@ -335,6 +343,14 @@ public ListenableFuture createDataset( _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(createDatasetSerializer.serialize(request)); _request.putHeaderParams("Test-Header", _plainSerDe.serializeString(testHeaderArg)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().call(createDatasetChannel, _request.build(), createDatasetDeserializer); } @@ -344,6 +360,14 @@ public ListenableFuture> getDataset( Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().call(getDatasetChannel, _request.build(), getDatasetDeserializer); } @@ -352,6 +376,14 @@ public ListenableFuture getRawData(AuthHeader authHeader, ResourceI Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .call( getRawDataChannel, @@ -365,6 +397,14 @@ public ListenableFuture getAliasedRawData( Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .call( getAliasedRawDataChannel, @@ -378,6 +418,14 @@ public ListenableFuture> maybeGetRawData( Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .call( maybeGetRawDataChannel, @@ -391,6 +439,14 @@ public ListenableFuture getAliasedString( Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().call(getAliasedStringChannel, _request.build(), getAliasedStringDeserializer); } @@ -399,6 +455,14 @@ public ListenableFuture uploadRawData(AuthHeader authHeader, BinaryRequest Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(_runtime.bodySerDe().serialize(input)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().call(uploadRawDataChannel, _request.build(), uploadRawDataDeserializer); } @@ -407,6 +471,14 @@ public ListenableFuture uploadAliasedRawData(AuthHeader authHeader, Binary Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(_runtime.bodySerDe().serialize(input)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .call(uploadAliasedRawDataChannel, _request.build(), uploadAliasedRawDataDeserializer); } @@ -416,6 +488,14 @@ public ListenableFuture> getBranches(AuthHeader authHeader, Resource Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().call(getBranchesChannel, _request.build(), getBranchesDeserializer); } @@ -426,6 +506,14 @@ public ListenableFuture> getBranchesDeprecated( Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .call(getBranchesDeprecatedChannel, _request.build(), getBranchesDeprecatedDeserializer); } @@ -437,6 +525,14 @@ public ListenableFuture> getBranchesDeprecatedForRemoval( Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .call( getBranchesDeprecatedForRemovalChannel, @@ -451,6 +547,14 @@ public ListenableFuture> resolveBranch( _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); _request.putPathParams("branch", _plainSerDe.serializeString(branch)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().call(resolveBranchChannel, _request.build(), resolveBranchDeserializer); } @@ -459,6 +563,14 @@ public ListenableFuture> testParam(AuthHeader authHeader, Resou Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().call(testParamChannel, _request.build(), testParamDeserializer); } @@ -485,6 +597,14 @@ public ListenableFuture testQueryParams( if (optionalEnd.isPresent()) { _request.putQueryParams("optionalEnd", _plainSerDe.serializeRid(optionalEnd.get())); } + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().call(testQueryParamsChannel, _request.build(), testQueryParamsDeserializer); } @@ -511,6 +631,14 @@ public ListenableFuture testNoResponseQueryParams( if (optionalEnd.isPresent()) { _request.putQueryParams("optionalEnd", _plainSerDe.serializeRid(optionalEnd.get())); } + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .call( testNoResponseQueryParamsChannel, @@ -522,6 +650,14 @@ public ListenableFuture testNoResponseQueryParams( public ListenableFuture testBoolean(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().call(testBooleanChannel, _request.build(), testBooleanDeserializer); } @@ -529,6 +665,14 @@ public ListenableFuture testBoolean(AuthHeader authHeader) { public ListenableFuture testDouble(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().call(testDoubleChannel, _request.build(), testDoubleDeserializer); } @@ -536,6 +680,14 @@ public ListenableFuture testDouble(AuthHeader authHeader) { public ListenableFuture testInteger(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().call(testIntegerChannel, _request.build(), testIntegerDeserializer); } @@ -545,6 +697,14 @@ public ListenableFuture> testPostOptional( Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(testPostOptionalSerializer.serialize(maybeString)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().call(testPostOptionalChannel, _request.build(), testPostOptionalDeserializer); } @@ -559,6 +719,14 @@ public ListenableFuture testOptionalIntegerAndDouble( if (maybeDouble.isPresent()) { _request.putQueryParams("maybeDouble", _plainSerDe.serializeDouble(maybeDouble.getAsDouble())); } + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .call( testOptionalIntegerAndDoubleChannel, @@ -575,6 +743,14 @@ public ListenableFuture getForStrings( for (AliasedString stringsElement : strings) { _request.putQueryParams("strings", _plainSerDe.serializeString(stringsElement.get())); } + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().call(getForStringsChannel, _request.build(), getForStringsDeserializer); } diff --git a/conjure-java-core/src/integrationInput/java/servicevanilla/com/palantir/another/TestServiceBlocking.java b/conjure-java-core/src/integrationInput/java/servicevanilla/com/palantir/another/TestServiceBlocking.java index ded99ecc3..a32bc77ff 100644 --- a/conjure-java-core/src/integrationInput/java/servicevanilla/com/palantir/another/TestServiceBlocking.java +++ b/conjure-java-core/src/integrationInput/java/servicevanilla/com/palantir/another/TestServiceBlocking.java @@ -322,6 +322,14 @@ static TestServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Co public Map getFileSystems(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .callBlocking(getFileSystemsChannel, _request.build(), getFileSystemsDeserializer); } @@ -332,6 +340,14 @@ public Dataset createDataset(AuthHeader authHeader, String testHeaderArg, Create _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(createDatasetSerializer.serialize(request)); _request.putHeaderParams("Test-Header", _plainSerDe.serializeString(testHeaderArg)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .callBlocking(createDatasetChannel, _request.build(), createDatasetDeserializer); } @@ -341,6 +357,14 @@ public Optional getDataset(AuthHeader authHeader, ResourceIdentifier da Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().callBlocking(getDatasetChannel, _request.build(), getDatasetDeserializer); } @@ -349,6 +373,14 @@ public InputStream getRawData(AuthHeader authHeader, ResourceIdentifier datasetR Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .callBlocking( getRawDataChannel, @@ -361,6 +393,14 @@ public InputStream getAliasedRawData(AuthHeader authHeader, ResourceIdentifier d Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .callBlocking( getAliasedRawDataChannel, @@ -373,6 +413,14 @@ public Optional maybeGetRawData(AuthHeader authHeader, ResourceIden Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .callBlocking( maybeGetRawDataChannel, @@ -385,6 +433,14 @@ public AliasedString getAliasedString(AuthHeader authHeader, ResourceIdentifier Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .callBlocking(getAliasedStringChannel, _request.build(), getAliasedStringDeserializer); } @@ -394,6 +450,14 @@ public void uploadRawData(AuthHeader authHeader, BinaryRequestBody input) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(_runtime.bodySerDe().serialize(input)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } _runtime.clients().callBlocking(uploadRawDataChannel, _request.build(), uploadRawDataDeserializer); } @@ -402,6 +466,14 @@ public void uploadAliasedRawData(AuthHeader authHeader, BinaryRequestBody input) Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(_runtime.bodySerDe().serialize(input)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } _runtime.clients() .callBlocking(uploadAliasedRawDataChannel, _request.build(), uploadAliasedRawDataDeserializer); } @@ -411,6 +483,14 @@ public Set getBranches(AuthHeader authHeader, ResourceIdentifier dataset Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().callBlocking(getBranchesChannel, _request.build(), getBranchesDeserializer); } @@ -420,6 +500,14 @@ public Set getBranchesDeprecated(AuthHeader authHeader, ResourceIdentifi Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .callBlocking( getBranchesDeprecatedChannel, _request.build(), getBranchesDeprecatedDeserializer); @@ -431,6 +519,14 @@ public Set getBranchesDeprecatedForRemoval(AuthHeader authHeader, Resour Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .callBlocking( getBranchesDeprecatedForRemovalChannel, @@ -444,6 +540,14 @@ public Optional resolveBranch(AuthHeader authHeader, ResourceIdentifier _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); _request.putPathParams("branch", _plainSerDe.serializeString(branch)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .callBlocking(resolveBranchChannel, _request.build(), resolveBranchDeserializer); } @@ -453,6 +557,14 @@ public Optional testParam(AuthHeader authHeader, ResourceIdentifier data Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().callBlocking(testParamChannel, _request.build(), testParamDeserializer); } @@ -479,6 +591,14 @@ public int testQueryParams( if (optionalEnd.isPresent()) { _request.putQueryParams("optionalEnd", _plainSerDe.serializeRid(optionalEnd.get())); } + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .callBlocking(testQueryParamsChannel, _request.build(), testQueryParamsDeserializer); } @@ -506,6 +626,14 @@ public void testNoResponseQueryParams( if (optionalEnd.isPresent()) { _request.putQueryParams("optionalEnd", _plainSerDe.serializeRid(optionalEnd.get())); } + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } _runtime.clients() .callBlocking( testNoResponseQueryParamsChannel, @@ -517,6 +645,14 @@ public void testNoResponseQueryParams( public boolean testBoolean(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().callBlocking(testBooleanChannel, _request.build(), testBooleanDeserializer); } @@ -524,6 +660,14 @@ public boolean testBoolean(AuthHeader authHeader) { public double testDouble(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().callBlocking(testDoubleChannel, _request.build(), testDoubleDeserializer); } @@ -531,6 +675,14 @@ public double testDouble(AuthHeader authHeader) { public int testInteger(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().callBlocking(testIntegerChannel, _request.build(), testIntegerDeserializer); } @@ -539,6 +691,14 @@ public Optional testPostOptional(AuthHeader authHeader, Optional Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(testPostOptionalSerializer.serialize(maybeString)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients() .callBlocking(testPostOptionalChannel, _request.build(), testPostOptionalDeserializer); } @@ -554,6 +714,14 @@ public void testOptionalIntegerAndDouble( if (maybeDouble.isPresent()) { _request.putQueryParams("maybeDouble", _plainSerDe.serializeDouble(maybeDouble.getAsDouble())); } + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } _runtime.clients() .callBlocking( testOptionalIntegerAndDoubleChannel, @@ -570,6 +738,14 @@ public void getForStrings( for (AliasedString stringsElement : strings) { _request.putQueryParams("strings", _plainSerDe.serializeString(stringsElement.get())); } + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } _runtime.clients().callBlocking(getForStringsChannel, _request.build(), getForStringsDeserializer); } diff --git a/conjure-java-core/src/integrationInput/java/servicevanilla/test/api/CookieServiceAsync.java b/conjure-java-core/src/integrationInput/java/servicevanilla/test/api/CookieServiceAsync.java index f02385029..727bea4b6 100644 --- a/conjure-java-core/src/integrationInput/java/servicevanilla/test/api/CookieServiceAsync.java +++ b/conjure-java-core/src/integrationInput/java/servicevanilla/test/api/CookieServiceAsync.java @@ -40,6 +40,14 @@ static CookieServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Con public ListenableFuture eatCookies(BearerToken token) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Cookie", "PALANTIR_TOKEN=" + _plainSerDe.serializeBearerToken(token)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } return _runtime.clients().call(eatCookiesChannel, _request.build(), eatCookiesDeserializer); } diff --git a/conjure-java-core/src/integrationInput/java/servicevanilla/test/api/CookieServiceBlocking.java b/conjure-java-core/src/integrationInput/java/servicevanilla/test/api/CookieServiceBlocking.java index a92e5169b..91772ca73 100644 --- a/conjure-java-core/src/integrationInput/java/servicevanilla/test/api/CookieServiceBlocking.java +++ b/conjure-java-core/src/integrationInput/java/servicevanilla/test/api/CookieServiceBlocking.java @@ -39,6 +39,14 @@ static CookieServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, public void eatCookies(BearerToken token) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Cookie", "PALANTIR_TOKEN=" + _plainSerDe.serializeBearerToken(token)); + if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe() + .errorParameterDeserializationFormat() + .get() + .toString()); + } _runtime.clients().callBlocking(eatCookiesChannel, _request.build(), eatCookiesDeserializer); } diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/another/ConjureErrors.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/another/ConjureErrors.java index 5ae29129e..ea26d2a5e 100644 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/another/ConjureErrors.java +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/another/ConjureErrors.java @@ -9,6 +9,7 @@ import com.palantir.conjure.java.api.errors.ServiceException; import com.palantir.logsafe.Preconditions; import com.palantir.logsafe.Safe; +import java.util.Map; import javax.annotation.Nullable; import javax.annotation.processing.Generated; import org.jetbrains.annotations.Contract; @@ -51,20 +52,28 @@ public static record DifferentPackageErrParameters() {} public static final class DifferentPackageErrSerializableError extends AbstractSerializableError { + @org.jspecify.annotations.Nullable + private final Map legacyParameters; + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) DifferentPackageErrSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") DifferentPackageErrParameters parameters) { + @JsonProperty("parameters") DifferentPackageErrParameters parameters, + @JsonProperty("legacyParameters") @org.jspecify.annotations.Nullable + Map legacyParameters) { super(errorCode, errorName, errorInstanceId, parameters); + this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder() - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()); + SerializableError.Builder builder = SerializableError.builder(); + if (legacyParameters != null) { + builder.putAllParameters(legacyParameters); + } else { + } + builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); return builder.build(); } } @@ -72,12 +81,9 @@ public SerializableError toSerializableError() { public static final class DifferentPackageErrException extends RemoteException { private DifferentPackageErrSerializableError error; - private int status; - public DifferentPackageErrException(DifferentPackageErrSerializableError error, int status) { super(error.toSerializableError(), status); this.error = error; - this.status = status; } public DifferentPackageErrSerializableError error() { diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/another/EndpointSpecificErrors.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/another/EndpointSpecificErrors.java index 36e908a18..61d594225 100644 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/another/EndpointSpecificErrors.java +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/another/EndpointSpecificErrors.java @@ -8,7 +8,9 @@ import com.palantir.conjure.java.api.errors.SerializableError; import com.palantir.logsafe.Preconditions; import com.palantir.logsafe.Safe; +import java.util.Map; import javax.annotation.processing.Generated; +import org.jspecify.annotations.Nullable; @Generated("com.palantir.conjure.java.types.ErrorGenerator") public final class EndpointSpecificErrors { @@ -28,20 +30,27 @@ public static record DifferentPackageParameters() {} public static final class DifferentPackageSerializableError extends AbstractSerializableError { + @Nullable + private final Map legacyParameters; + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) DifferentPackageSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") DifferentPackageParameters parameters) { + @JsonProperty("parameters") DifferentPackageParameters parameters, + @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { super(errorCode, errorName, errorInstanceId, parameters); + this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder() - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()); + SerializableError.Builder builder = SerializableError.builder(); + if (legacyParameters != null) { + builder.putAllParameters(legacyParameters); + } else { + } + builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); return builder.build(); } } @@ -49,12 +58,9 @@ public SerializableError toSerializableError() { public static final class DifferentPackageException extends RemoteException { private DifferentPackageSerializableError error; - private int status; - public DifferentPackageException(DifferentPackageSerializableError error, int status) { super(error.toSerializableError(), status); this.error = error; - this.status = status; } public DifferentPackageSerializableError error() { diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ConjureErrors.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ConjureErrors.java index aad81d9cc..ca5650870 100644 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ConjureErrors.java +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ConjureErrors.java @@ -12,6 +12,7 @@ import com.palantir.logsafe.SafeArg; import com.palantir.logsafe.Unsafe; import com.palantir.logsafe.UnsafeArg; +import java.util.Map; import java.util.Objects; import javax.annotation.Nullable; import javax.annotation.processing.Generated; @@ -388,157 +389,218 @@ public static record InvalidTypeDefinitionParameters( public static final class ConflictingCauseSafeArgSerializableError extends AbstractSerializableError { + @org.jspecify.annotations.Nullable + private final Map legacyParameters; + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) ConflictingCauseSafeArgSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") ConflictingCauseSafeArgParameters parameters) { + @JsonProperty("parameters") ConflictingCauseSafeArgParameters parameters, + @JsonProperty("legacyParameters") @org.jspecify.annotations.Nullable + Map legacyParameters) { super(errorCode, errorName, errorInstanceId, parameters); + this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder() - .putParameters("cause", Objects.toString(parameters().cause_())) - .putParameters("shouldThrow", Objects.toString(parameters().shouldThrow_())) - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()); + SerializableError.Builder builder = SerializableError.builder(); + if (legacyParameters != null) { + builder.putAllParameters(legacyParameters); + } else { + builder.putParameters("cause", Objects.toString(parameters().cause_())) + .putParameters( + "shouldThrow", Objects.toString(parameters().shouldThrow_())); + } + builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); return builder.build(); } } public static final class ConflictingCauseSafeArgErrSerializableError extends AbstractSerializableError { + @org.jspecify.annotations.Nullable + private final Map legacyParameters; + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) ConflictingCauseSafeArgErrSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") ConflictingCauseSafeArgErrParameters parameters) { + @JsonProperty("parameters") ConflictingCauseSafeArgErrParameters parameters, + @JsonProperty("legacyParameters") @org.jspecify.annotations.Nullable + Map legacyParameters) { super(errorCode, errorName, errorInstanceId, parameters); + this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder() - .putParameters("cause", Objects.toString(parameters().cause_())) - .putParameters("shouldThrow", Objects.toString(parameters().shouldThrow_())) - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()); + SerializableError.Builder builder = SerializableError.builder(); + if (legacyParameters != null) { + builder.putAllParameters(legacyParameters); + } else { + builder.putParameters("cause", Objects.toString(parameters().cause_())) + .putParameters( + "shouldThrow", Objects.toString(parameters().shouldThrow_())); + } + builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); return builder.build(); } } public static final class ConflictingCauseUnsafeArgSerializableError extends AbstractSerializableError { + @org.jspecify.annotations.Nullable + private final Map legacyParameters; + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) ConflictingCauseUnsafeArgSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") ConflictingCauseUnsafeArgParameters parameters) { + @JsonProperty("parameters") ConflictingCauseUnsafeArgParameters parameters, + @JsonProperty("legacyParameters") @org.jspecify.annotations.Nullable + Map legacyParameters) { super(errorCode, errorName, errorInstanceId, parameters); + this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder() - .putParameters("cause", Objects.toString(parameters().cause_())) - .putParameters("shouldThrow", Objects.toString(parameters().shouldThrow_())) - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()); + SerializableError.Builder builder = SerializableError.builder(); + if (legacyParameters != null) { + builder.putAllParameters(legacyParameters); + } else { + builder.putParameters("cause", Objects.toString(parameters().cause_())) + .putParameters( + "shouldThrow", Objects.toString(parameters().shouldThrow_())); + } + builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); return builder.build(); } } public static final class ErrorWithComplexArgsSerializableError extends AbstractSerializableError { + @org.jspecify.annotations.Nullable + private final Map legacyParameters; + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) ErrorWithComplexArgsSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") ErrorWithComplexArgsParameters parameters) { + @JsonProperty("parameters") ErrorWithComplexArgsParameters parameters, + @JsonProperty("legacyParameters") @org.jspecify.annotations.Nullable + Map legacyParameters) { super(errorCode, errorName, errorInstanceId, parameters); + this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder() - .putParameters( - "primitiveExample", Objects.toString(parameters().primitiveExample())) - .putParameters( - "collectionExample", Objects.toString(parameters().collectionExample())) - .putParameters( - "nestedCollectionExample", - Objects.toString(parameters().nestedCollectionExample())) - .putParameters( - "optionalExample", Objects.toString(parameters().optionalExample())) - .putParameters( - "objectReference", Objects.toString(parameters().objectReference())) - .putParameters("unionExample", Objects.toString(parameters().unionExample())) - .putParameters("enumExample", Objects.toString(parameters().enumExample())) - .putParameters("stringAlias", Objects.toString(parameters().stringAlias())) - .putParameters( - "optionalAlias", Objects.toString(parameters().optionalAlias())) - .putParameters( - "collectionAlias", Objects.toString(parameters().collectionAlias())) - .putParameters("nestedAlias", Objects.toString(parameters().nestedAlias())) - .putParameters( - "externalExample", Objects.toString(parameters().externalExample())) - .putParameters("anyExample", Objects.toString(parameters().anyExample())) - .putParameters("emptyObject", Objects.toString(parameters().emptyObject())) - .putParameters( - "complexExample", Objects.toString(parameters().complexExample())) - .putParameters( - "safetyExample", Objects.toString(parameters().safetyExample())) - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()); + SerializableError.Builder builder = SerializableError.builder(); + if (legacyParameters != null) { + builder.putAllParameters(legacyParameters); + } else { + builder.putParameters( + "primitiveExample", + Objects.toString(parameters().primitiveExample())) + .putParameters( + "collectionExample", + Objects.toString(parameters().collectionExample())) + .putParameters( + "nestedCollectionExample", + Objects.toString(parameters().nestedCollectionExample())) + .putParameters( + "optionalExample", Objects.toString(parameters().optionalExample())) + .putParameters( + "objectReference", Objects.toString(parameters().objectReference())) + .putParameters( + "unionExample", Objects.toString(parameters().unionExample())) + .putParameters( + "enumExample", Objects.toString(parameters().enumExample())) + .putParameters( + "stringAlias", Objects.toString(parameters().stringAlias())) + .putParameters( + "optionalAlias", Objects.toString(parameters().optionalAlias())) + .putParameters( + "collectionAlias", Objects.toString(parameters().collectionAlias())) + .putParameters( + "nestedAlias", Objects.toString(parameters().nestedAlias())) + .putParameters( + "externalExample", Objects.toString(parameters().externalExample())) + .putParameters( + "anyExample", Objects.toString(parameters().anyExample())) + .putParameters( + "emptyObject", Objects.toString(parameters().emptyObject())) + .putParameters( + "complexExample", Objects.toString(parameters().complexExample())) + .putParameters( + "safetyExample", Objects.toString(parameters().safetyExample())); + } + builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); return builder.build(); } } public static final class InvalidServiceDefinitionSerializableError extends AbstractSerializableError { + @org.jspecify.annotations.Nullable + private final Map legacyParameters; + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) InvalidServiceDefinitionSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") InvalidServiceDefinitionParameters parameters) { + @JsonProperty("parameters") InvalidServiceDefinitionParameters parameters, + @JsonProperty("legacyParameters") @org.jspecify.annotations.Nullable + Map legacyParameters) { super(errorCode, errorName, errorInstanceId, parameters); + this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder() - .putParameters("serviceName", Objects.toString(parameters().serviceName())) - .putParameters("serviceDef", Objects.toString(parameters().serviceDef())) - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()); + SerializableError.Builder builder = SerializableError.builder(); + if (legacyParameters != null) { + builder.putAllParameters(legacyParameters); + } else { + builder.putParameters( + "serviceName", Objects.toString(parameters().serviceName())) + .putParameters( + "serviceDef", Objects.toString(parameters().serviceDef())); + } + builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); return builder.build(); } } public static final class InvalidTypeDefinitionSerializableError extends AbstractSerializableError { + @org.jspecify.annotations.Nullable + private final Map legacyParameters; + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) InvalidTypeDefinitionSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") InvalidTypeDefinitionParameters parameters) { + @JsonProperty("parameters") InvalidTypeDefinitionParameters parameters, + @JsonProperty("legacyParameters") @org.jspecify.annotations.Nullable + Map legacyParameters) { super(errorCode, errorName, errorInstanceId, parameters); + this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder() - .putParameters("typeName", Objects.toString(parameters().typeName())) - .putParameters("typeDef", Objects.toString(parameters().typeDef())) - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()); + SerializableError.Builder builder = SerializableError.builder(); + if (legacyParameters != null) { + builder.putAllParameters(legacyParameters); + } else { + builder.putParameters("typeName", Objects.toString(parameters().typeName())) + .putParameters("typeDef", Objects.toString(parameters().typeDef())); + } + builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); return builder.build(); } } @@ -546,12 +608,9 @@ public SerializableError toSerializableError() { public static final class ConflictingCauseSafeArgException extends RemoteException { private ConflictingCauseSafeArgSerializableError error; - private int status; - public ConflictingCauseSafeArgException(ConflictingCauseSafeArgSerializableError error, int status) { super(error.toSerializableError(), status); this.error = error; - this.status = status; } public ConflictingCauseSafeArgSerializableError error() { @@ -562,12 +621,9 @@ public ConflictingCauseSafeArgSerializableError error() { public static final class ConflictingCauseSafeArgErrException extends RemoteException { private ConflictingCauseSafeArgErrSerializableError error; - private int status; - public ConflictingCauseSafeArgErrException(ConflictingCauseSafeArgErrSerializableError error, int status) { super(error.toSerializableError(), status); this.error = error; - this.status = status; } public ConflictingCauseSafeArgErrSerializableError error() { @@ -578,12 +634,9 @@ public ConflictingCauseSafeArgErrSerializableError error() { public static final class ConflictingCauseUnsafeArgException extends RemoteException { private ConflictingCauseUnsafeArgSerializableError error; - private int status; - public ConflictingCauseUnsafeArgException(ConflictingCauseUnsafeArgSerializableError error, int status) { super(error.toSerializableError(), status); this.error = error; - this.status = status; } public ConflictingCauseUnsafeArgSerializableError error() { @@ -594,12 +647,9 @@ public ConflictingCauseUnsafeArgSerializableError error() { public static final class ErrorWithComplexArgsException extends RemoteException { private ErrorWithComplexArgsSerializableError error; - private int status; - public ErrorWithComplexArgsException(ErrorWithComplexArgsSerializableError error, int status) { super(error.toSerializableError(), status); this.error = error; - this.status = status; } public ErrorWithComplexArgsSerializableError error() { @@ -610,12 +660,9 @@ public ErrorWithComplexArgsSerializableError error() { public static final class InvalidServiceDefinitionException extends RemoteException { private InvalidServiceDefinitionSerializableError error; - private int status; - public InvalidServiceDefinitionException(InvalidServiceDefinitionSerializableError error, int status) { super(error.toSerializableError(), status); this.error = error; - this.status = status; } public InvalidServiceDefinitionSerializableError error() { @@ -626,12 +673,9 @@ public InvalidServiceDefinitionSerializableError error() { public static final class InvalidTypeDefinitionException extends RemoteException { private InvalidTypeDefinitionSerializableError error; - private int status; - public InvalidTypeDefinitionException(InvalidTypeDefinitionSerializableError error, int status) { super(error.toSerializableError(), status); this.error = error; - this.status = status; } public InvalidTypeDefinitionSerializableError error() { diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ConjureJavaErrors.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ConjureJavaErrors.java index b7bb11d6a..cb8949661 100644 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ConjureJavaErrors.java +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ConjureJavaErrors.java @@ -9,6 +9,7 @@ import com.palantir.conjure.java.api.errors.ServiceException; import com.palantir.logsafe.Preconditions; import com.palantir.logsafe.Safe; +import java.util.Map; import javax.annotation.Nullable; import javax.annotation.processing.Generated; import org.jetbrains.annotations.Contract; @@ -51,20 +52,28 @@ public static record JavaCompilationFailedParameters() {} public static final class JavaCompilationFailedSerializableError extends AbstractSerializableError { + @org.jspecify.annotations.Nullable + private final Map legacyParameters; + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) JavaCompilationFailedSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") JavaCompilationFailedParameters parameters) { + @JsonProperty("parameters") JavaCompilationFailedParameters parameters, + @JsonProperty("legacyParameters") @org.jspecify.annotations.Nullable + Map legacyParameters) { super(errorCode, errorName, errorInstanceId, parameters); + this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder() - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()); + SerializableError.Builder builder = SerializableError.builder(); + if (legacyParameters != null) { + builder.putAllParameters(legacyParameters); + } else { + } + builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); return builder.build(); } } @@ -72,12 +81,9 @@ public SerializableError toSerializableError() { public static final class JavaCompilationFailedException extends RemoteException { private JavaCompilationFailedSerializableError error; - private int status; - public JavaCompilationFailedException(JavaCompilationFailedSerializableError error, int status) { super(error.toSerializableError(), status); this.error = error; - this.status = status; } public JavaCompilationFailedSerializableError error() { diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EndpointSpecificErrors.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EndpointSpecificErrors.java index 76d25a537..fc4e5cf20 100644 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EndpointSpecificErrors.java +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EndpointSpecificErrors.java @@ -9,8 +9,10 @@ import com.palantir.logsafe.Preconditions; import com.palantir.logsafe.Safe; import com.palantir.logsafe.Unsafe; +import java.util.Map; import java.util.Objects; import javax.annotation.processing.Generated; +import org.jspecify.annotations.Nullable; @Generated("com.palantir.conjure.java.types.ErrorGenerator") public final class EndpointSpecificErrors { @@ -31,22 +33,29 @@ public static record EndpointErrorParameters( public static final class EndpointErrorSerializableError extends AbstractSerializableError { + @Nullable + private final Map legacyParameters; + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) EndpointErrorSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") EndpointErrorParameters parameters) { + @JsonProperty("parameters") EndpointErrorParameters parameters, + @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { super(errorCode, errorName, errorInstanceId, parameters); + this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder() - .putParameters("typeName", Objects.toString(parameters().typeName())) - .putParameters("typeDef", Objects.toString(parameters().typeDef())) - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()); + SerializableError.Builder builder = SerializableError.builder(); + if (legacyParameters != null) { + builder.putAllParameters(legacyParameters); + } else { + builder.putParameters("typeName", Objects.toString(parameters().typeName())) + .putParameters("typeDef", Objects.toString(parameters().typeDef())); + } + builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); return builder.build(); } } @@ -54,12 +63,9 @@ public SerializableError toSerializableError() { public static final class EndpointErrorException extends RemoteException { private EndpointErrorSerializableError error; - private int status; - public EndpointErrorException(EndpointErrorSerializableError error, int status) { super(error.toSerializableError(), status); this.error = error; - this.status = status; } public EndpointErrorSerializableError error() { diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EndpointSpecificTwoErrors.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EndpointSpecificTwoErrors.java index 963a0547a..4723d7b54 100644 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EndpointSpecificTwoErrors.java +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EndpointSpecificTwoErrors.java @@ -8,7 +8,9 @@ import com.palantir.conjure.java.api.errors.SerializableError; import com.palantir.logsafe.Preconditions; import com.palantir.logsafe.Safe; +import java.util.Map; import javax.annotation.processing.Generated; +import org.jspecify.annotations.Nullable; @Generated("com.palantir.conjure.java.types.ErrorGenerator") public final class EndpointSpecificTwoErrors { @@ -28,20 +30,27 @@ public static record DifferentNamespaceParameters() {} public static final class DifferentNamespaceSerializableError extends AbstractSerializableError { + @Nullable + private final Map legacyParameters; + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) DifferentNamespaceSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") DifferentNamespaceParameters parameters) { + @JsonProperty("parameters") DifferentNamespaceParameters parameters, + @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { super(errorCode, errorName, errorInstanceId, parameters); + this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder() - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()); + SerializableError.Builder builder = SerializableError.builder(); + if (legacyParameters != null) { + builder.putAllParameters(legacyParameters); + } else { + } + builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); return builder.build(); } } @@ -49,12 +58,9 @@ public SerializableError toSerializableError() { public static final class DifferentNamespaceException extends RemoteException { private DifferentNamespaceSerializableError error; - private int status; - public DifferentNamespaceException(DifferentNamespaceSerializableError error, int status) { super(error.toSerializableError(), status); this.error = error; - this.status = status; } public DifferentNamespaceSerializableError error() { diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/TestErrors.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/TestErrors.java index 391a3a9ed..6d55990d9 100644 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/TestErrors.java +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/TestErrors.java @@ -12,6 +12,7 @@ import java.util.Map; import java.util.Objects; import javax.annotation.processing.Generated; +import org.jspecify.annotations.Nullable; @Generated("com.palantir.conjure.java.types.ErrorGenerator") public final class TestErrors { @@ -53,65 +54,85 @@ public static record NotFoundParameters(@JsonProperty("resource") @Safe String r public static final class ComplicatedParametersSerializableError extends AbstractSerializableError { + @Nullable + private final Map legacyParameters; + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) ComplicatedParametersSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") ComplicatedParametersParameters parameters) { + @JsonProperty("parameters") ComplicatedParametersParameters parameters, + @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { super(errorCode, errorName, errorInstanceId, parameters); + this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder() - .putParameters( - "complicatedObjectMap", - Objects.toString(parameters().complicatedObjectMap())) - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()); + SerializableError.Builder builder = SerializableError.builder(); + if (legacyParameters != null) { + builder.putAllParameters(legacyParameters); + } else { + builder.putParameters( + "complicatedObjectMap", Objects.toString(parameters().complicatedObjectMap())); + } + builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); return builder.build(); } } public static final class InvalidArgumentSerializableError extends AbstractSerializableError { + @Nullable + private final Map legacyParameters; + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) InvalidArgumentSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") InvalidArgumentParameters parameters) { + @JsonProperty("parameters") InvalidArgumentParameters parameters, + @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { super(errorCode, errorName, errorInstanceId, parameters); + this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder() - .putParameters("field", Objects.toString(parameters().field())) - .putParameters("value", Objects.toString(parameters().value())) - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()); + SerializableError.Builder builder = SerializableError.builder(); + if (legacyParameters != null) { + builder.putAllParameters(legacyParameters); + } else { + builder.putParameters("field", Objects.toString(parameters().field())) + .putParameters("value", Objects.toString(parameters().value())); + } + builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); return builder.build(); } } public static final class NotFoundSerializableError extends AbstractSerializableError { + @Nullable + private final Map legacyParameters; + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) NotFoundSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") NotFoundParameters parameters) { + @JsonProperty("parameters") NotFoundParameters parameters, + @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { super(errorCode, errorName, errorInstanceId, parameters); + this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder() - .putParameters("resource", Objects.toString(parameters().resource())) - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()); + SerializableError.Builder builder = SerializableError.builder(); + if (legacyParameters != null) { + builder.putAllParameters(legacyParameters); + } else { + builder.putParameters("resource", Objects.toString(parameters().resource())); + } + builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); return builder.build(); } } @@ -119,12 +140,9 @@ public SerializableError toSerializableError() { public static final class ComplicatedParametersException extends RemoteException { private ComplicatedParametersSerializableError error; - private int status; - public ComplicatedParametersException(ComplicatedParametersSerializableError error, int status) { super(error.toSerializableError(), status); this.error = error; - this.status = status; } public ComplicatedParametersSerializableError error() { @@ -135,12 +153,9 @@ public ComplicatedParametersSerializableError error() { public static final class InvalidArgumentException extends RemoteException { private InvalidArgumentSerializableError error; - private int status; - public InvalidArgumentException(InvalidArgumentSerializableError error, int status) { super(error.toSerializableError(), status); this.error = error; - this.status = status; } public InvalidArgumentSerializableError error() { @@ -151,12 +166,9 @@ public InvalidArgumentSerializableError error() { public static final class NotFoundException extends RemoteException { private NotFoundSerializableError error; - private int status; - public NotFoundException(NotFoundSerializableError error, int status) { super(error.toSerializableError(), status); this.error = error; - this.status = status; } public NotFoundSerializableError error() { diff --git a/conjure-java-core/src/main/java/com/palantir/conjure/java/services/dialogue/DefaultStaticFactoryMethodGenerator.java b/conjure-java-core/src/main/java/com/palantir/conjure/java/services/dialogue/DefaultStaticFactoryMethodGenerator.java index 9864d625b..da48f4bb5 100644 --- a/conjure-java-core/src/main/java/com/palantir/conjure/java/services/dialogue/DefaultStaticFactoryMethodGenerator.java +++ b/conjure-java-core/src/main/java/com/palantir/conjure/java/services/dialogue/DefaultStaticFactoryMethodGenerator.java @@ -252,6 +252,17 @@ private MethodSpec clientImpl(EndpointDefinition def) { .orElseGet(() -> def.getEndpointName().get() + "Deserializer")); methodBuilder.addCode(request); + // If the BodySerDe.errorParameterDeserializationFormat field is set, add the header + methodBuilder.addCode(CodeBlock.builder() + .beginControlFlow("if ($L.bodySerDe().errorParameterDeserializationFormat().isPresent())", RUNTIME) + .add( + "$L.putHeaderParams($S," + + " $L.bodySerDe().errorParameterDeserializationFormat().get().toString());", + REQUEST, + "Accept-Conjure-Error-Parameter-Format", // TODO(pm): make this public. + RUNTIME) + .endControlFlow() + .build()); methodBuilder.addCode(methodType.switchBy(def.getReturns().isPresent() ? "return " : "", "return ")); methodBuilder.addCode(execute); diff --git a/conjure-java-core/src/main/java/com/palantir/conjure/java/types/ErrorGenerator.java b/conjure-java-core/src/main/java/com/palantir/conjure/java/types/ErrorGenerator.java index 50191e375..4f52eb8a4 100644 --- a/conjure-java-core/src/main/java/com/palantir/conjure/java/types/ErrorGenerator.java +++ b/conjure-java-core/src/main/java/com/palantir/conjure/java/types/ErrorGenerator.java @@ -57,6 +57,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; import javax.lang.model.element.Modifier; +import org.jspecify.annotations.Nullable; public final class ErrorGenerator implements Generator { @@ -200,16 +201,12 @@ private static TypeSpec generateRemoteExceptionType(ErrorDefinition errorDefinit .addField(FieldSpec.builder(serializableErrorClassName, "error") .addModifiers(Modifier.PRIVATE) .build()) - .addField(FieldSpec.builder(int.class, "status") - .addModifiers(Modifier.PRIVATE) - .build()) .addMethod(MethodSpec.constructorBuilder() .addModifiers(Modifier.PUBLIC) .addParameter(serializableErrorClassName, "error") .addParameter(int.class, "status") .addStatement("super(error.toSerializableError(), status)") .addStatement("this.error = error") - .addStatement("this.status = status") .build()) .addMethod(MethodSpec.methodBuilder("error") .addModifiers(Modifier.PUBLIC) @@ -260,7 +257,15 @@ private static TypeSpec generateSerializableError(ErrorDefinition errorDefinitio .addMember("value", "$S", "parameters") .build()) .build()) - .addCode("super(errorCode, errorName, errorInstanceId, parameters);") + .addParameter(ParameterSpec.builder( + ParameterizedTypeName.get(Map.class, String.class, String.class), "legacyParameters") + .addAnnotation(AnnotationSpec.builder(JsonProperty.class) + .addMember("value", "$S", "legacyParameters") + .build()) + .addAnnotation(Nullable.class) + .build()) + .addStatement("super(errorCode, errorName, errorInstanceId, parameters)") + .addStatement("this.legacyParameters = legacyParameters") .build(); // Create the toSerializableError method @@ -268,20 +273,31 @@ private static TypeSpec generateSerializableError(ErrorDefinition errorDefinitio .addModifiers(Modifier.PUBLIC) .returns(SerializableError.class); CodeBlock.Builder builder = CodeBlock.builder() - .add("$T builder = $T.builder()", SerializableError.Builder.class, SerializableError.class); + .add("$T builder = $T.builder();", SerializableError.Builder.class, SerializableError.class); + + // If therea are legacy parameters, just use those. + + builder.beginControlFlow("if (legacyParameters != null)") + .addStatement("builder.putAllParameters(legacyParameters)") + .nextControlFlow("else"); + // Add all parameters List allArgs = new ArrayList<>(); allArgs.addAll(errorDefinition.getSafeArgs()); allArgs.addAll(errorDefinition.getUnsafeArgs()); - for (FieldDefinition field : allArgs) { + + for (int i = 0; i < allArgs.size(); i++) { + FieldDefinition field = allArgs.get(i); String fieldName = field.getFieldName().get(); builder.add( - ".putParameters($S, $T.toString(parameters().$L()))", + (i == 0 ? "builder" : "") + ".putParameters($S, $T.toString(parameters().$L()))" + + (i == allArgs.size() - 1 ? ";" : ""), fieldName, Objects.class, JavaNameSanitizer.sanitizeErrorParameterName(fieldName)); } - builder.add(".errorCode(errorCode())") + builder.endControlFlow(); + builder.add("builder.errorCode(errorCode())") .add(".errorName(errorName())") .add(".errorInstanceId(errorInstanceId());"); toSerializableErrorBuilder.addCode(builder.build()); @@ -292,6 +308,11 @@ private static TypeSpec generateSerializableError(ErrorDefinition errorDefinitio .addModifiers(Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL) .superclass( ParameterizedTypeName.get(ClassName.get(AbstractSerializableError.class), parametersClassName)) + .addField(FieldSpec.builder( + ParameterizedTypeName.get(Map.class, String.class, String.class), "legacyParameters") + .addModifiers(Modifier.PRIVATE, Modifier.FINAL) + .addAnnotation(Nullable.class) + .build()) .addMethod(constructor) .addMethod(toSerializableErrorBuilder.build()); diff --git a/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowEteResource.java b/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowEteResource.java index 1fd334de4..6517c9016 100644 --- a/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowEteResource.java +++ b/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowEteResource.java @@ -199,7 +199,7 @@ public String jsonErrorsHeader(AuthHeader authHeader, String headerParameter) { @Override public String errorParameterSerialization(AuthHeader authHeader, String headerParameter) { - if (headerParameter.equals("JSON") || headerParameter.equals("TOSTRING")) { + if (headerParameter.startsWith("JSON") || headerParameter.equals("TOSTRING")) { throw ConjureErrors.errorWithComplexArgs( PrimitiveExample.builder() .stringVal("example-string") diff --git a/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowServiceEteTest.java b/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowServiceEteTest.java index bfb104374..2fe25ee84 100644 --- a/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowServiceEteTest.java +++ b/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowServiceEteTest.java @@ -37,6 +37,7 @@ import com.palantir.dialogue.clients.DialogueClients; import com.palantir.ri.ResourceIdentifier; import com.palantir.tokens.auth.AuthHeader; +import dialogue.com.palantir.product.ConjureErrors.ErrorWithComplexArgsException; import dialogue.com.palantir.product.EteBinaryServiceBlocking; import dialogue.com.palantir.product.EteServiceAsync; import dialogue.com.palantir.product.EteServiceBlocking; @@ -566,11 +567,12 @@ public void testErrorParametersSerializedAsJson() { } @Test - public void test_json_parameter_errors() { - // Get the parameters when we use TOSTRING serialization + public void testStringParametersDoNotChangeWhenUsingJsonAndJavaString() { Map toStringParams = Map.of(); Map jsonParams = Map.of(); try { + // The `TOSTRING` header does nothing: it's not used in `ConjureExceptions` to change any serialization + // behavior. It's just a way to tell the EteResource to throw an error. client.errorParameterSerialization(AuthHeader.valueOf("authHeader"), "TOSTRING"); } catch (RemoteException e) { toStringParams = e.getError().parameters(); @@ -578,13 +580,23 @@ public void test_json_parameter_errors() { // Get the parameters when we use JSON serialization try { - client.errorParameterSerialization(AuthHeader.valueOf("authHeader"), "JSON"); + // The `JSON+JAVA-STRING` header is read by `ConjureExceptions` to change the serialization + // behavior. The `JSON` representation of the parameters is sent in the `parameters` field of the Conjure + // error, and a new field `legacyParameters` is added containing the string representation of the + // parameters. + client.errorParameterSerialization(AuthHeader.valueOf("authHeader"), "JSON+JAVA-STRING"); } catch (RemoteException e) { + // .getError() returns the SerializableError which should contain the legacy parameters sent over the wire. jsonParams = e.getError().parameters(); + // e should be an instance of ErrorWithComplexArgsException, which has rich parameters as well. + assertThat(e).isInstanceOfSatisfying(ErrorWithComplexArgsException.class, exception -> { + assertThat(exception.error().parameters().optionalExample().getOptionalString()) + .contains("optional-value"); + }); } // Assert that the two maps contain the same keys and values, logging any differences - assertThat(jsonParams).containsExactlyInAnyOrderEntriesOf(toStringParams); + assertThat(jsonParams).containsExactlyEntriesOf(toStringParams); } private static HttpURLConnection openConnectionToTestApi(String path) throws IOException { diff --git a/conjure-java-core/src/test/java/com/palantir/conjure/java/parameterized/ParameterizedConjureGenerationTest.java b/conjure-java-core/src/test/java/com/palantir/conjure/java/parameterized/ParameterizedConjureGenerationTest.java index 1d0bab314..87c7961b3 100644 --- a/conjure-java-core/src/test/java/com/palantir/conjure/java/parameterized/ParameterizedConjureGenerationTest.java +++ b/conjure-java-core/src/test/java/com/palantir/conjure/java/parameterized/ParameterizedConjureGenerationTest.java @@ -51,25 +51,6 @@ public final class ParameterizedConjureGenerationTest { public File tempDir; private static List getTestCases() { - // return List.of(ParameterizedTestCase.builder() - // .name("errors") - // .docs("Testing error generation.") - // .files(Path.of("example-errors.yml")) - // .files(Path.of("example-errors-other.yml")) - // .files(Path.of("ete-service.yml")) - // .options(Options.builder() - // .undertowServicePrefix(true) - // .useImmutableBytes(true) - // .excludeEmptyOptionals(true) - // .jetbrainsContractAnnotations(true) - // .build()) - // .generatorTypes(List.of( - // GeneratorType.ERROR, - // GeneratorType.OBJECT, - // GeneratorType.UNDERTOW, - // GeneratorType.DIALOGUE, - // GeneratorType.ENDPOINT_ERROR)) - // .build()); return TestCases.get(); } diff --git a/conjure-java-undertow-runtime/src/main/java/com/palantir/conjure/java/undertow/runtime/ConjureError.java b/conjure-java-undertow-runtime/src/main/java/com/palantir/conjure/java/undertow/runtime/ConjureError.java index 9ac4865a5..7781849b8 100644 --- a/conjure-java-undertow-runtime/src/main/java/com/palantir/conjure/java/undertow/runtime/ConjureError.java +++ b/conjure-java-undertow-runtime/src/main/java/com/palantir/conjure/java/undertow/runtime/ConjureError.java @@ -16,6 +16,8 @@ package com.palantir.conjure.java.undertow.runtime; +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; import com.palantir.conjure.java.api.errors.CheckedServiceException; import com.palantir.conjure.java.api.errors.EndpointServiceException; @@ -56,7 +58,15 @@ record ConjureError( @JsonProperty("errorCode") String errorCode, @JsonProperty("errorName") String errorName, @JsonProperty("errorInstanceId") String errorInstanceId, - @JsonProperty("parameters") Map parameters) { + @JsonProperty("parameters") Map parameters, + @JsonIgnore Optional> legacyParameters) { + + @JsonProperty("legacyParameters") + // Only populate the legacy parameters field if it is non-empty. + @JsonInclude(JsonInclude.Include.NON_NULL) + Map getLegacyParametersForSerialization() { + return legacyParameters.orElse(null); + } ConjureError { Preconditions.checkNotNull(errorCode, "errorCode cannot be null"); @@ -71,7 +81,8 @@ static ConjureError fromCheckedServiceException(CheckedServiceException exceptio exception.getErrorType().code().name(), exception.getErrorType().name(), exception.getErrorInstanceId(), - parameters); + parameters, + Optional.empty()); } static ConjureError fromEndpointServiceException(EndpointServiceException exception) { @@ -80,7 +91,8 @@ static ConjureError fromEndpointServiceException(EndpointServiceException except exception.getErrorType().code().name(), exception.getErrorType().name(), exception.getErrorInstanceId(), - parameters); + parameters, + Optional.empty()); } static ConjureError fromServiceException(ServiceException exception) { @@ -89,7 +101,12 @@ static ConjureError fromServiceException(ServiceException exception) { parameters.put(arg.getName(), Objects.toString(arg.getValue())); } ErrorType errorType = exception.getErrorType(); - return new ConjureError(errorType.code().name(), errorType.name(), exception.getErrorInstanceId(), parameters); + return new ConjureError( + errorType.code().name(), + errorType.name(), + exception.getErrorInstanceId(), + parameters, + Optional.empty()); } /** @@ -100,7 +117,27 @@ static ConjureError fromServiceException(ServiceException exception) { static ConjureError fromServiceExceptionWithJsonSerializedParameterValues(ServiceException exception) { Map parameters = getParametersFromArgs(exception.getArgs()); ErrorType errorType = exception.getErrorType(); - return new ConjureError(errorType.code().name(), errorType.name(), exception.getErrorInstanceId(), parameters); + return new ConjureError( + errorType.code().name(), + errorType.name(), + exception.getErrorInstanceId(), + parameters, + Optional.empty()); + } + + static ConjureError fromServiceExceptionWithJsonAndJavaStringSerializedParameterValues(ServiceException exception) { + Map parameters = getParametersFromArgs(exception.getArgs()); + Map legacyParameters = new HashMap<>(); + for (Arg arg : exception.getArgs()) { + legacyParameters.put(arg.getName(), Objects.toString(arg.getValue())); + } + ErrorType errorType = exception.getErrorType(); + return new ConjureError( + errorType.code().name(), + errorType.name(), + exception.getErrorInstanceId(), + parameters, + Optional.of(legacyParameters)); } /** @@ -112,7 +149,12 @@ static ConjureError fromServiceExceptionWithJsonSerializedParameterValues(Servic */ static ConjureError fromRemoteException(RemoteException exception) { SerializableError error = exception.getError(); - return new ConjureError(error.errorCode(), error.errorName(), error.errorInstanceId(), Collections.emptyMap()); + return new ConjureError( + error.errorCode(), + error.errorName(), + error.errorInstanceId(), + Collections.emptyMap(), + Optional.empty()); } private static boolean shouldIncludeArgInParameters(Arg arg) { diff --git a/conjure-java-undertow-runtime/src/main/java/com/palantir/conjure/java/undertow/runtime/ConjureExceptions.java b/conjure-java-undertow-runtime/src/main/java/com/palantir/conjure/java/undertow/runtime/ConjureExceptions.java index 5a40505ed..3a90da4c1 100644 --- a/conjure-java-undertow-runtime/src/main/java/com/palantir/conjure/java/undertow/runtime/ConjureExceptions.java +++ b/conjure-java-undertow-runtime/src/main/java/com/palantir/conjure/java/undertow/runtime/ConjureExceptions.java @@ -130,18 +130,32 @@ private static void serviceException(HttpServerExchange exchange, ServiceExcepti .toString() .equalsIgnoreCase(ConjureErrorParameterFormat.JSON_FORMAT.toString()); + boolean isJsonStringErrorParameterValueFormat = isHeaderPresent + && maybeErrorParamFormatHeader + .get() + .toString() + .equalsIgnoreCase(ConjureErrorParameterFormat.JSON_AND_JAVA_STRING_FORMAT.toString()); + // Log unrecognized format if present but not JSON - if (isHeaderPresent && !isJsonErrorParameterValueFormat) { + if (isHeaderPresent && !isJsonErrorParameterValueFormat && !isJsonStringErrorParameterValueFormat) { log.info( "Unrecognized Conjure error parameter format header", SafeArg.of("headerValue", maybeErrorParamFormatHeader.get())); } // Use the appropriate serialization based on format - logWithSerializationFormat(exception, isJsonErrorParameterValueFormat); - ConjureError conjureError = isJsonErrorParameterValueFormat - ? ConjureError.fromServiceExceptionWithJsonSerializedParameterValues(exception) - : ConjureError.fromServiceException(exception); + + ConjureError conjureError; + if (isJsonErrorParameterValueFormat) { + logWithSerializationFormat(exception, Optional.of(ConjureErrorParameterFormat.JSON_FORMAT)); + conjureError = ConjureError.fromServiceExceptionWithJsonSerializedParameterValues(exception); + } else if (isJsonStringErrorParameterValueFormat) { + logWithSerializationFormat(exception, Optional.of(ConjureErrorParameterFormat.JSON_AND_JAVA_STRING_FORMAT)); + conjureError = ConjureError.fromServiceExceptionWithJsonAndJavaStringSerializedParameterValues(exception); + } else { + logWithSerializationFormat(exception, Optional.empty()); + conjureError = ConjureError.fromServiceException(exception); + } writeResponse( exchange, Optional.of(conjureError), exception.getErrorType().httpErrorCode()); @@ -290,20 +304,20 @@ private static boolean isResponseStarted(HttpServerExchange exchange) { } private static void logWithSerializationFormat( - ServiceException serviceException, boolean isUsingJsonSerializationForParameters) { + ServiceException serviceException, Optional parameterFormat) { if (serviceException.getErrorType().httpErrorCode() / 100 == 4 /* client error */) { log.info( "Error handling request", SafeArg.of("errorInstanceId", serviceException.getErrorInstanceId()), SafeArg.of("errorName", serviceException.getErrorType().name()), - SafeArg.of("isUsingJsonSerializationForParameters", isUsingJsonSerializationForParameters), + SafeArg.of("parameterFormat", parameterFormat), serviceException); } else { log.error( "Error handling request", SafeArg.of("errorInstanceId", serviceException.getErrorInstanceId()), SafeArg.of("errorName", serviceException.getErrorType().name()), - SafeArg.of("isUsingJsonSerializationForParameters", isUsingJsonSerializationForParameters), + SafeArg.of("parameterFormat", parameterFormat), serviceException); } } diff --git a/conjure-java-undertow-runtime/src/test/java/com/palantir/conjure/java/undertow/runtime/ConjureExceptionHandlerTest.java b/conjure-java-undertow-runtime/src/test/java/com/palantir/conjure/java/undertow/runtime/ConjureExceptionHandlerTest.java index 9a8247be8..8cac4d233 100644 --- a/conjure-java-undertow-runtime/src/test/java/com/palantir/conjure/java/undertow/runtime/ConjureExceptionHandlerTest.java +++ b/conjure-java-undertow-runtime/src/test/java/com/palantir/conjure/java/undertow/runtime/ConjureExceptionHandlerTest.java @@ -138,6 +138,7 @@ static Stream differentPackageExceptions() { Arguments.of((Supplier) () -> new DifferentPackageEndpointException(null))); } + @SuppressWarnings("removal") private static final class DifferentPackageCheckedException extends CheckedServiceException { @SuppressWarnings("removal") private DifferentPackageCheckedException(@Nullable Throwable cause) { @@ -145,6 +146,7 @@ private DifferentPackageCheckedException(@Nullable Throwable cause) { } } + @SuppressWarnings("removal") private static final class DifferentPackageEndpointException extends CheckedServiceException { @SuppressWarnings("removal") private DifferentPackageEndpointException(@Nullable Throwable cause) { @@ -186,6 +188,7 @@ static Stream exceptionsWithOptionals() { private record ArgumentWithOptionals(Optional> optOfList, List> listOfOpt) {} + @SuppressWarnings("removal") private static final class OptionalCheckedException extends CheckedServiceException { @SuppressWarnings("removal") From 5e66172d744ef23f7b665d4de9aa2cc8ef4f80f7 Mon Sep 17 00:00:00 2001 From: Pritham Marupaka Date: Tue, 12 Aug 2025 18:06:27 -0400 Subject: [PATCH 10/26] cleanup unneeded files --- .../com/palantir/product/AnyExample.java | 162 ----- .../com/palantir/product/CollectionAlias.java | 70 -- .../palantir/product/CollectionExample.java | 219 ------- .../com/palantir/product/ComplexExample.java | 232 ------- .../com/palantir/product/EmptyObject.java | 28 - .../com/palantir/product/EmptyUnion.java | 186 ------ .../com/palantir/product/EnumExample.java | 205 ------ .../com/palantir/product/ExternalExample.java | 183 ------ .../com/palantir/product/NestedAlias.java | 52 -- .../product/NestedCollectionExample.java | 226 ------- .../com/palantir/product/ObjectReference.java | 169 ----- .../com/palantir/product/OptionalAlias.java | 60 -- .../com/palantir/product/OptionalExample.java | 206 ------ .../palantir/product/PrimitiveExample.java | 345 ---------- .../com/palantir/product/SafetyExample.java | 176 ----- .../com/palantir/product/StringAliasEx.java | 58 -- .../com/palantir/product/UnionExample.java | 579 ----------------- .../com/palantir/another/ConjureErrors.java | 93 --- .../com/palantir/product/AnyExample.java | 162 ----- .../com/palantir/product/CollectionAlias.java | 70 -- .../palantir/product/CollectionExample.java | 221 ------- .../com/palantir/product/ComplexExample.java | 237 ------- .../com/palantir/product/ConjureErrors.java | 614 +----------------- .../palantir/product/ConjureJavaErrors.java | 93 --- .../com/palantir/product/EmptyObject.java | 28 - .../com/palantir/product/EmptyUnion.java | 186 ------ .../com/palantir/product/EnumExample.java | 205 ------ .../com/palantir/product/ExternalExample.java | 185 ------ .../com/palantir/product/NestedAlias.java | 52 -- .../product/NestedCollectionExample.java | 227 ------- .../com/palantir/product/ObjectReference.java | 169 ----- .../com/palantir/product/OptionalAlias.java | 60 -- .../com/palantir/product/OptionalExample.java | 210 ------ .../palantir/product/PrimitiveExample.java | 345 ---------- .../com/palantir/product/SafetyExample.java | 176 ----- .../com/palantir/product/StringAliasEx.java | 58 -- .../com/palantir/product/UnionExample.java | 579 ----------------- .../src/test/resources/ete-service.yml | 4 - 38 files changed, 3 insertions(+), 7127 deletions(-) delete mode 100644 conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/AnyExample.java delete mode 100644 conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/CollectionAlias.java delete mode 100644 conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/CollectionExample.java delete mode 100644 conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/ComplexExample.java delete mode 100644 conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/EmptyObject.java delete mode 100644 conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/EmptyUnion.java delete mode 100644 conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/EnumExample.java delete mode 100644 conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/ExternalExample.java delete mode 100644 conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/NestedAlias.java delete mode 100644 conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/NestedCollectionExample.java delete mode 100644 conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/ObjectReference.java delete mode 100644 conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/OptionalAlias.java delete mode 100644 conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/OptionalExample.java delete mode 100644 conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/PrimitiveExample.java delete mode 100644 conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/SafetyExample.java delete mode 100644 conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/StringAliasEx.java delete mode 100644 conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/UnionExample.java delete mode 100644 conjure-java-core/src/integrationInput/java/undertow/com/palantir/another/ConjureErrors.java delete mode 100644 conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/AnyExample.java delete mode 100644 conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/CollectionAlias.java delete mode 100644 conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/CollectionExample.java delete mode 100644 conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ComplexExample.java delete mode 100644 conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ConjureJavaErrors.java delete mode 100644 conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EmptyObject.java delete mode 100644 conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EmptyUnion.java delete mode 100644 conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EnumExample.java delete mode 100644 conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ExternalExample.java delete mode 100644 conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/NestedAlias.java delete mode 100644 conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/NestedCollectionExample.java delete mode 100644 conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ObjectReference.java delete mode 100644 conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/OptionalAlias.java delete mode 100644 conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/OptionalExample.java delete mode 100644 conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/PrimitiveExample.java delete mode 100644 conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/SafetyExample.java delete mode 100644 conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/StringAliasEx.java delete mode 100644 conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/UnionExample.java diff --git a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/AnyExample.java b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/AnyExample.java deleted file mode 100644 index d8c7c2800..000000000 --- a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/AnyExample.java +++ /dev/null @@ -1,162 +0,0 @@ -package jersey.com.palantir.product; - -import com.fasterxml.jackson.annotation.JsonIgnoreProperties; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.fasterxml.jackson.annotation.JsonSetter; -import com.fasterxml.jackson.annotation.Nulls; -import com.fasterxml.jackson.databind.annotation.JsonDeserialize; -import com.google.errorprone.annotations.CheckReturnValue; -import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.SafeArg; -import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; -import java.util.ArrayList; -import java.util.Collections; -import java.util.LinkedHashMap; -import java.util.List; -import java.util.Map; -import javax.annotation.Nonnull; -import javax.annotation.Nullable; -import javax.annotation.processing.Generated; - -@JsonDeserialize(builder = AnyExample.Builder.class) -@Generated("com.palantir.conjure.java.types.BeanGenerator") -public final class AnyExample { - private final Object anyValue; - - private final Map anyMap; - - private int memoizedHashCode; - - private AnyExample(Object anyValue, Map anyMap) { - validateFields(anyValue, anyMap); - this.anyValue = anyValue; - this.anyMap = Collections.unmodifiableMap(anyMap); - } - - @JsonProperty("anyValue") - public Object getAnyValue() { - return this.anyValue; - } - - @JsonProperty("anyMap") - public Map getAnyMap() { - return this.anyMap; - } - - @Override - public boolean equals(@Nullable Object other) { - return this == other || (other instanceof AnyExample && equalTo((AnyExample) other)); - } - - private boolean equalTo(AnyExample other) { - if (this.memoizedHashCode != 0 - && other.memoizedHashCode != 0 - && this.memoizedHashCode != other.memoizedHashCode) { - return false; - } - return this.anyValue.equals(other.anyValue) && this.anyMap.equals(other.anyMap); - } - - @Override - public int hashCode() { - int result = memoizedHashCode; - if (result == 0) { - int hash = 1; - hash = 31 * hash + this.anyValue.hashCode(); - hash = 31 * hash + this.anyMap.hashCode(); - result = hash; - memoizedHashCode = result; - } - return result; - } - - @Override - public String toString() { - return "AnyExample{anyValue: " + anyValue + ", anyMap: " + anyMap + '}'; - } - - public static AnyExample of(Object anyValue, Map anyMap) { - return builder().anyValue(anyValue).anyMap(anyMap).build(); - } - - private static void validateFields(Object anyValue, Map anyMap) { - List missingFields = null; - missingFields = addFieldIfMissing(missingFields, anyValue, "anyValue"); - missingFields = addFieldIfMissing(missingFields, anyMap, "anyMap"); - if (missingFields != null) { - throw new SafeIllegalArgumentException( - "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); - } - } - - private static List addFieldIfMissing(List prev, Object fieldValue, String fieldName) { - List missingFields = prev; - if (fieldValue == null) { - if (missingFields == null) { - missingFields = new ArrayList<>(2); - } - missingFields.add(fieldName); - } - return missingFields; - } - - public static Builder builder() { - return new Builder(); - } - - @Generated("com.palantir.conjure.java.types.BeanBuilderGenerator") - @JsonIgnoreProperties(ignoreUnknown = true) - public static final class Builder { - boolean _buildInvoked; - - private Object anyValue; - - private Map anyMap = new LinkedHashMap<>(); - - private Builder() {} - - public Builder from(AnyExample other) { - checkNotBuilt(); - anyValue(other.getAnyValue()); - anyMap(other.getAnyMap()); - return this; - } - - @JsonSetter("anyValue") - public Builder anyValue(@Nonnull Object anyValue) { - checkNotBuilt(); - this.anyValue = Preconditions.checkNotNull(anyValue, "anyValue cannot be null"); - return this; - } - - @JsonSetter(value = "anyMap", nulls = Nulls.SKIP) - public Builder anyMap(@Nonnull Map anyMap) { - checkNotBuilt(); - this.anyMap = new LinkedHashMap<>(Preconditions.checkNotNull(anyMap, "anyMap cannot be null")); - return this; - } - - public Builder putAllAnyMap(@Nonnull Map anyMap) { - checkNotBuilt(); - this.anyMap.putAll(Preconditions.checkNotNull(anyMap, "anyMap cannot be null")); - return this; - } - - public Builder anyMap(String key, Object value) { - checkNotBuilt(); - this.anyMap.put(key, value); - return this; - } - - @CheckReturnValue - public AnyExample build() { - checkNotBuilt(); - this._buildInvoked = true; - return new AnyExample(anyValue, anyMap); - } - - private void checkNotBuilt() { - Preconditions.checkState(!_buildInvoked, "Build has already been called"); - } - } -} diff --git a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/CollectionAlias.java b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/CollectionAlias.java deleted file mode 100644 index 1e9d469f9..000000000 --- a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/CollectionAlias.java +++ /dev/null @@ -1,70 +0,0 @@ -package jersey.com.palantir.product; - -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonValue; -import com.palantir.logsafe.Preconditions; -import java.util.Collections; -import java.util.List; -import javax.annotation.Nonnull; -import javax.annotation.Nullable; -import javax.annotation.processing.Generated; - -@Generated("com.palantir.conjure.java.types.AliasGenerator") -public final class CollectionAlias { - private static final CollectionAlias EMPTY = new CollectionAlias(); - - private final List value; - - private int memoizedHashCode; - - private CollectionAlias(@Nonnull List value) { - this.value = Preconditions.checkNotNull(value, "value cannot be null"); - } - - private CollectionAlias() { - this(Collections.emptyList()); - } - - @JsonValue - public List get() { - return value; - } - - @Override - public String toString() { - return value.toString(); - } - - @Override - public boolean equals(@Nullable Object other) { - return this == other || (other instanceof CollectionAlias && equalTo((CollectionAlias) other)); - } - - private boolean equalTo(CollectionAlias other) { - if (this.memoizedHashCode != 0 - && other.memoizedHashCode != 0 - && this.memoizedHashCode != other.memoizedHashCode) { - return false; - } - return this.value.equals(other.value); - } - - @Override - public int hashCode() { - int result = memoizedHashCode; - if (result == 0) { - result = this.value.hashCode(); - memoizedHashCode = result; - } - return result; - } - - @JsonCreator(mode = JsonCreator.Mode.DELEGATING) - public static CollectionAlias of(@Nonnull List value) { - return new CollectionAlias(value); - } - - public static CollectionAlias empty() { - return EMPTY; - } -} diff --git a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/CollectionExample.java b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/CollectionExample.java deleted file mode 100644 index 1f4162545..000000000 --- a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/CollectionExample.java +++ /dev/null @@ -1,219 +0,0 @@ -package jersey.com.palantir.product; - -import com.fasterxml.jackson.annotation.JsonIgnoreProperties; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.fasterxml.jackson.annotation.JsonSetter; -import com.fasterxml.jackson.annotation.Nulls; -import com.fasterxml.jackson.databind.annotation.JsonDeserialize; -import com.google.errorprone.annotations.CheckReturnValue; -import com.palantir.conjure.java.lib.internal.ConjureCollections; -import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.SafeArg; -import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; -import java.util.ArrayList; -import java.util.Collections; -import java.util.LinkedHashMap; -import java.util.List; -import java.util.Map; -import java.util.Set; -import javax.annotation.Nonnull; -import javax.annotation.Nullable; -import javax.annotation.processing.Generated; - -@JsonDeserialize(builder = CollectionExample.Builder.class) -@Generated("com.palantir.conjure.java.types.BeanGenerator") -public final class CollectionExample { - private final List stringList; - - private final Set stringSet; - - private final Map stringMap; - - private int memoizedHashCode; - - private CollectionExample(List stringList, Set stringSet, Map stringMap) { - validateFields(stringList, stringSet, stringMap); - this.stringList = ConjureCollections.unmodifiableList(stringList); - this.stringSet = Collections.unmodifiableSet(stringSet); - this.stringMap = Collections.unmodifiableMap(stringMap); - } - - @JsonProperty("stringList") - public List getStringList() { - return this.stringList; - } - - @JsonProperty("stringSet") - public Set getStringSet() { - return this.stringSet; - } - - @JsonProperty("stringMap") - public Map getStringMap() { - return this.stringMap; - } - - @Override - public boolean equals(@Nullable Object other) { - return this == other || (other instanceof CollectionExample && equalTo((CollectionExample) other)); - } - - private boolean equalTo(CollectionExample other) { - if (this.memoizedHashCode != 0 - && other.memoizedHashCode != 0 - && this.memoizedHashCode != other.memoizedHashCode) { - return false; - } - return this.stringList.equals(other.stringList) - && this.stringSet.equals(other.stringSet) - && this.stringMap.equals(other.stringMap); - } - - @Override - public int hashCode() { - int result = memoizedHashCode; - if (result == 0) { - int hash = 1; - hash = 31 * hash + this.stringList.hashCode(); - hash = 31 * hash + this.stringSet.hashCode(); - hash = 31 * hash + this.stringMap.hashCode(); - result = hash; - memoizedHashCode = result; - } - return result; - } - - @Override - public String toString() { - return "CollectionExample{stringList: " + stringList + ", stringSet: " + stringSet + ", stringMap: " + stringMap - + '}'; - } - - public static CollectionExample of(List stringList, Set stringSet, Map stringMap) { - return builder() - .stringList(stringList) - .stringSet(stringSet) - .stringMap(stringMap) - .build(); - } - - private static void validateFields(List stringList, Set stringSet, Map stringMap) { - List missingFields = null; - missingFields = addFieldIfMissing(missingFields, stringList, "stringList"); - missingFields = addFieldIfMissing(missingFields, stringSet, "stringSet"); - missingFields = addFieldIfMissing(missingFields, stringMap, "stringMap"); - if (missingFields != null) { - throw new SafeIllegalArgumentException( - "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); - } - } - - private static List addFieldIfMissing(List prev, Object fieldValue, String fieldName) { - List missingFields = prev; - if (fieldValue == null) { - if (missingFields == null) { - missingFields = new ArrayList<>(3); - } - missingFields.add(fieldName); - } - return missingFields; - } - - public static Builder builder() { - return new Builder(); - } - - @Generated("com.palantir.conjure.java.types.BeanBuilderGenerator") - @JsonIgnoreProperties(ignoreUnknown = true) - public static final class Builder { - boolean _buildInvoked; - - private List stringList = ConjureCollections.newList(); - - private Set stringSet = ConjureCollections.newSet(); - - private Map stringMap = new LinkedHashMap<>(); - - private Builder() {} - - public Builder from(CollectionExample other) { - checkNotBuilt(); - stringList(other.getStringList()); - stringSet(other.getStringSet()); - stringMap(other.getStringMap()); - return this; - } - - @JsonSetter(value = "stringList", nulls = Nulls.SKIP) - public Builder stringList(@Nonnull Iterable stringList) { - checkNotBuilt(); - this.stringList = - ConjureCollections.newList(Preconditions.checkNotNull(stringList, "stringList cannot be null")); - return this; - } - - public Builder addAllStringList(@Nonnull Iterable stringList) { - checkNotBuilt(); - ConjureCollections.addAll( - this.stringList, Preconditions.checkNotNull(stringList, "stringList cannot be null")); - return this; - } - - public Builder stringList(String stringList) { - checkNotBuilt(); - this.stringList.add(stringList); - return this; - } - - @JsonSetter(value = "stringSet", nulls = Nulls.SKIP) - public Builder stringSet(@Nonnull Iterable stringSet) { - checkNotBuilt(); - this.stringSet = - ConjureCollections.newSet(Preconditions.checkNotNull(stringSet, "stringSet cannot be null")); - return this; - } - - public Builder addAllStringSet(@Nonnull Iterable stringSet) { - checkNotBuilt(); - ConjureCollections.addAll( - this.stringSet, Preconditions.checkNotNull(stringSet, "stringSet cannot be null")); - return this; - } - - public Builder stringSet(String stringSet) { - checkNotBuilt(); - this.stringSet.add(stringSet); - return this; - } - - @JsonSetter(value = "stringMap", nulls = Nulls.SKIP) - public Builder stringMap(@Nonnull Map stringMap) { - checkNotBuilt(); - this.stringMap = new LinkedHashMap<>(Preconditions.checkNotNull(stringMap, "stringMap cannot be null")); - return this; - } - - public Builder putAllStringMap(@Nonnull Map stringMap) { - checkNotBuilt(); - this.stringMap.putAll(Preconditions.checkNotNull(stringMap, "stringMap cannot be null")); - return this; - } - - public Builder stringMap(String key, String value) { - checkNotBuilt(); - this.stringMap.put(key, value); - return this; - } - - @CheckReturnValue - public CollectionExample build() { - checkNotBuilt(); - this._buildInvoked = true; - return new CollectionExample(stringList, stringSet, stringMap); - } - - private void checkNotBuilt() { - Preconditions.checkState(!_buildInvoked, "Build has already been called"); - } - } -} diff --git a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/ComplexExample.java b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/ComplexExample.java deleted file mode 100644 index adcfa6e29..000000000 --- a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/ComplexExample.java +++ /dev/null @@ -1,232 +0,0 @@ -package jersey.com.palantir.product; - -import com.fasterxml.jackson.annotation.JsonIgnoreProperties; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.fasterxml.jackson.annotation.JsonSetter; -import com.fasterxml.jackson.annotation.Nulls; -import com.fasterxml.jackson.databind.annotation.JsonDeserialize; -import com.google.errorprone.annotations.CheckReturnValue; -import com.palantir.conjure.java.lib.internal.ConjureCollections; -import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.SafeArg; -import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; -import java.util.ArrayList; -import java.util.Collections; -import java.util.LinkedHashMap; -import java.util.List; -import java.util.Map; -import java.util.Optional; -import java.util.function.Function; -import javax.annotation.Nonnull; -import javax.annotation.Nullable; -import javax.annotation.processing.Generated; - -@JsonDeserialize(builder = ComplexExample.Builder.class) -@Generated("com.palantir.conjure.java.types.BeanGenerator") -public final class ComplexExample { - private final Map>> metadata; - - private final EnumExample status; - - private final List variants; - - private final Optional external; - - private int memoizedHashCode; - - private ComplexExample( - Map>> metadata, - EnumExample status, - List variants, - Optional external) { - validateFields(metadata, status, variants, external); - this.metadata = Collections.unmodifiableMap(metadata); - this.status = status; - this.variants = ConjureCollections.unmodifiableList(variants); - this.external = external; - } - - @JsonProperty("metadata") - public Map>> getMetadata() { - return this.metadata; - } - - @JsonProperty("status") - public EnumExample getStatus() { - return this.status; - } - - @JsonProperty("variants") - public List getVariants() { - return this.variants; - } - - @JsonProperty("external") - public Optional getExternal() { - return this.external; - } - - @Override - public boolean equals(@Nullable Object other) { - return this == other || (other instanceof ComplexExample && equalTo((ComplexExample) other)); - } - - private boolean equalTo(ComplexExample other) { - if (this.memoizedHashCode != 0 - && other.memoizedHashCode != 0 - && this.memoizedHashCode != other.memoizedHashCode) { - return false; - } - return this.metadata.equals(other.metadata) - && this.status.equals(other.status) - && this.variants.equals(other.variants) - && this.external.equals(other.external); - } - - @Override - public int hashCode() { - int result = memoizedHashCode; - if (result == 0) { - int hash = 1; - hash = 31 * hash + this.metadata.hashCode(); - hash = 31 * hash + this.status.hashCode(); - hash = 31 * hash + this.variants.hashCode(); - hash = 31 * hash + this.external.hashCode(); - result = hash; - memoizedHashCode = result; - } - return result; - } - - @Override - public String toString() { - return "ComplexExample{metadata: " + metadata + ", status: " + status + ", variants: " + variants - + ", external: " + external + '}'; - } - - private static void validateFields( - Map>> metadata, - EnumExample status, - List variants, - Optional external) { - List missingFields = null; - missingFields = addFieldIfMissing(missingFields, metadata, "metadata"); - missingFields = addFieldIfMissing(missingFields, status, "status"); - missingFields = addFieldIfMissing(missingFields, variants, "variants"); - missingFields = addFieldIfMissing(missingFields, external, "external"); - if (missingFields != null) { - throw new SafeIllegalArgumentException( - "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); - } - } - - private static List addFieldIfMissing(List prev, Object fieldValue, String fieldName) { - List missingFields = prev; - if (fieldValue == null) { - if (missingFields == null) { - missingFields = new ArrayList<>(4); - } - missingFields.add(fieldName); - } - return missingFields; - } - - public static Builder builder() { - return new Builder(); - } - - @Generated("com.palantir.conjure.java.types.BeanBuilderGenerator") - @JsonIgnoreProperties(ignoreUnknown = true) - public static final class Builder { - boolean _buildInvoked; - - private Map>> metadata = new LinkedHashMap<>(); - - private EnumExample status; - - private List variants = ConjureCollections.newList(); - - private Optional external = Optional.empty(); - - private Builder() {} - - public Builder from(ComplexExample other) { - checkNotBuilt(); - metadata(other.getMetadata()); - status(other.getStatus()); - variants(other.getVariants()); - external(other.getExternal()); - return this; - } - - @JsonSetter(value = "metadata", nulls = Nulls.SKIP, contentNulls = Nulls.AS_EMPTY) - public Builder metadata(@Nonnull Map>> metadata) { - checkNotBuilt(); - this.metadata = new LinkedHashMap<>(Preconditions.checkNotNull(metadata, "metadata cannot be null")); - return this; - } - - public Builder putAllMetadata(@Nonnull Map>> metadata) { - checkNotBuilt(); - this.metadata.putAll(Preconditions.checkNotNull(metadata, "metadata cannot be null")); - return this; - } - - public Builder metadata(StringAliasEx key, Optional> value) { - checkNotBuilt(); - this.metadata.put(key, value); - return this; - } - - @JsonSetter("status") - public Builder status(@Nonnull EnumExample status) { - checkNotBuilt(); - this.status = Preconditions.checkNotNull(status, "status cannot be null"); - return this; - } - - @JsonSetter(value = "variants", nulls = Nulls.SKIP) - public Builder variants(@Nonnull Iterable variants) { - checkNotBuilt(); - this.variants = ConjureCollections.newList(Preconditions.checkNotNull(variants, "variants cannot be null")); - return this; - } - - public Builder addAllVariants(@Nonnull Iterable variants) { - checkNotBuilt(); - ConjureCollections.addAll(this.variants, Preconditions.checkNotNull(variants, "variants cannot be null")); - return this; - } - - public Builder variants(UnionExample variants) { - checkNotBuilt(); - this.variants.add(variants); - return this; - } - - @JsonSetter(value = "external", nulls = Nulls.SKIP) - public Builder external(@Nonnull Optional external) { - checkNotBuilt(); - this.external = Preconditions.checkNotNull(external, "external cannot be null") - .map(Function.identity()); - return this; - } - - public Builder external(long external) { - checkNotBuilt(); - this.external = Optional.of(Preconditions.checkNotNull(external, "external cannot be null")); - return this; - } - - @CheckReturnValue - public ComplexExample build() { - checkNotBuilt(); - this._buildInvoked = true; - return new ComplexExample(metadata, status, variants, external); - } - - private void checkNotBuilt() { - Preconditions.checkState(!_buildInvoked, "Build has already been called"); - } - } -} diff --git a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/EmptyObject.java b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/EmptyObject.java deleted file mode 100644 index 2aa865a01..000000000 --- a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/EmptyObject.java +++ /dev/null @@ -1,28 +0,0 @@ -package jersey.com.palantir.product; - -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonIgnoreProperties; -import com.fasterxml.jackson.databind.annotation.JsonSerialize; -import com.palantir.logsafe.Safe; -import javax.annotation.processing.Generated; - -@Safe -@JsonSerialize -@JsonIgnoreProperties(ignoreUnknown = true) -@Generated("com.palantir.conjure.java.types.BeanGenerator") -public final class EmptyObject { - private static final EmptyObject INSTANCE = new EmptyObject(); - - private EmptyObject() {} - - @Override - @Safe - public String toString() { - return "EmptyObject{}"; - } - - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - public static EmptyObject of() { - return INSTANCE; - } -} diff --git a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/EmptyUnion.java b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/EmptyUnion.java deleted file mode 100644 index 128be48b7..000000000 --- a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/EmptyUnion.java +++ /dev/null @@ -1,186 +0,0 @@ -package jersey.com.palantir.product; - -import com.fasterxml.jackson.annotation.JsonAnyGetter; -import com.fasterxml.jackson.annotation.JsonAnySetter; -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonIgnoreProperties; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.fasterxml.jackson.annotation.JsonTypeInfo; -import com.fasterxml.jackson.annotation.JsonValue; -import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.Safe; -import com.palantir.logsafe.SafeArg; -import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; -import java.util.Collections; -import java.util.HashMap; -import java.util.Map; -import java.util.function.Function; -import javax.annotation.Nonnull; -import javax.annotation.Nullable; -import javax.annotation.processing.Generated; - -@Generated("com.palantir.conjure.java.types.UnionGenerator") -public final class EmptyUnion { - private final Base value; - - @JsonCreator(mode = JsonCreator.Mode.DELEGATING) - private EmptyUnion(Base value) { - this.value = value; - } - - @JsonValue - private Base getValue() { - return value; - } - - public static EmptyUnion unknown(@Safe String type, Object value) { - switch (Preconditions.checkNotNull(type, "Type is required")) { - default: - return new EmptyUnion(new UnknownWrapper(type, Collections.singletonMap(type, value))); - } - } - - public T accept(Visitor visitor) { - return value.accept(visitor); - } - - @Override - public boolean equals(@Nullable Object other) { - return this == other || (other instanceof EmptyUnion && equalTo((EmptyUnion) other)); - } - - private boolean equalTo(EmptyUnion other) { - return this.value.equals(other.value); - } - - @Override - public int hashCode() { - return this.value.hashCode(); - } - - @Override - public String toString() { - return "EmptyUnion{value: " + value + '}'; - } - - public interface Visitor { - T visitUnknown(@Safe String unknownType); - - static UnknownStageVisitorBuilder builder() { - return new VisitorBuilder(); - } - } - - private static final class VisitorBuilder - implements UnknownStageVisitorBuilder, Completed_StageVisitorBuilder { - private Function unknownVisitor; - - @Override - public Completed_StageVisitorBuilder unknown(@Nonnull Function unknownVisitor) { - Preconditions.checkNotNull(unknownVisitor, "unknownVisitor cannot be null"); - this.unknownVisitor = unknownVisitor; - return this; - } - - @Override - public Completed_StageVisitorBuilder throwOnUnknown() { - this.unknownVisitor = unknownType -> { - throw new SafeIllegalArgumentException( - "Unknown variant of the 'EmptyUnion' union", SafeArg.of("unknownType", unknownType)); - }; - return this; - } - - @Override - public Visitor build() { - final Function unknownVisitor = this.unknownVisitor; - return new Visitor() { - @Override - public T visitUnknown(String value) { - return unknownVisitor.apply(value); - } - }; - } - } - - public interface UnknownStageVisitorBuilder { - Completed_StageVisitorBuilder unknown(@Nonnull Function unknownVisitor); - - Completed_StageVisitorBuilder throwOnUnknown(); - } - - public interface Completed_StageVisitorBuilder { - Visitor build(); - } - - @JsonTypeInfo( - use = JsonTypeInfo.Id.NAME, - include = JsonTypeInfo.As.EXISTING_PROPERTY, - property = "type", - visible = true, - defaultImpl = UnknownWrapper.class) - @JsonIgnoreProperties(ignoreUnknown = true) - private interface Base { - T accept(Visitor visitor); - } - - private static final class UnknownWrapper implements Base { - private final String type; - - private final Map value; - - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - private UnknownWrapper(@JsonProperty("type") String type) { - this(type, new HashMap()); - } - - private UnknownWrapper(@Nonnull String type, @Nonnull Map value) { - Preconditions.checkNotNull(type, "type cannot be null"); - Preconditions.checkNotNull(value, "value cannot be null"); - this.type = type; - this.value = value; - } - - @JsonProperty - private String getType() { - return type; - } - - @JsonAnyGetter - private Map getValue() { - return value; - } - - @JsonAnySetter - private void put(String key, Object val) { - value.put(key, val); - } - - @Override - public T accept(Visitor visitor) { - return visitor.visitUnknown(type); - } - - @Override - public boolean equals(@Nullable Object other) { - return this == other || (other instanceof UnknownWrapper && equalTo((UnknownWrapper) other)); - } - - private boolean equalTo(UnknownWrapper other) { - return this.type.equals(other.type) && this.value.equals(other.value); - } - - @Override - public int hashCode() { - int hash = 1; - hash = 31 * hash + this.type.hashCode(); - hash = 31 * hash + this.value.hashCode(); - return hash; - } - - @Override - public String toString() { - return "UnknownWrapper{type: " + type + ", value: " + value + '}'; - } - } -} diff --git a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/EnumExample.java b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/EnumExample.java deleted file mode 100644 index 6b6cacfc3..000000000 --- a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/EnumExample.java +++ /dev/null @@ -1,205 +0,0 @@ -package jersey.com.palantir.product; - -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonValue; -import com.google.errorprone.annotations.Immutable; -import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.Safe; -import com.palantir.logsafe.SafeArg; -import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; -import java.util.Arrays; -import java.util.Collections; -import java.util.List; -import java.util.Locale; -import java.util.function.Function; -import java.util.function.Supplier; -import javax.annotation.Nonnull; -import javax.annotation.Nullable; -import javax.annotation.processing.Generated; - -/** - * This class is used instead of a native enum to support unknown values. Rather than throw an exception, the - * {@link EnumExample#valueOf} method defaults to a new instantiation of {@link EnumExample} where - * {@link EnumExample#get} will return {@link EnumExample.Value#UNKNOWN}. - * - *

For example, {@code EnumExample.valueOf("corrupted value").get()} will return {@link EnumExample.Value#UNKNOWN}, - * but {@link EnumExample#toString} will return "corrupted value". - * - *

There is no method to access all instantiations of this class, since they cannot be known at compile time. - */ -@Generated("com.palantir.conjure.java.types.EnumGenerator") -@Safe -@Immutable -public final class EnumExample { - public static final EnumExample A = new EnumExample(Value.A, "A"); - - public static final EnumExample B = new EnumExample(Value.B, "B"); - - private static final List values = Collections.unmodifiableList(Arrays.asList(A, B)); - - private final Value value; - - private final String string; - - private EnumExample(Value value, String string) { - this.value = value; - this.string = string; - } - - public Value get() { - return this.value; - } - - @Override - @JsonValue - public String toString() { - return this.string; - } - - @Override - public boolean equals(@Nullable Object other) { - return (this == other) - || (this.value == Value.UNKNOWN - && other instanceof EnumExample - && this.string.equals(((EnumExample) other).string)); - } - - @Override - public int hashCode() { - return this.string.hashCode(); - } - - @JsonCreator(mode = JsonCreator.Mode.DELEGATING) - public static EnumExample valueOf(@Nonnull @Safe String value) { - Preconditions.checkNotNull(value, "value cannot be null"); - String upperCasedValue = value.toUpperCase(Locale.ROOT); - switch (upperCasedValue) { - case "A": - return A; - case "B": - return B; - default: - return new EnumExample(Value.UNKNOWN, upperCasedValue); - } - } - - public T accept(Visitor visitor) { - switch (value) { - case A: - return visitor.visitA(); - case B: - return visitor.visitB(); - default: - return visitor.visitUnknown(string); - } - } - - public static List values() { - return values; - } - - @Generated("com.palantir.conjure.java.types.EnumGenerator") - public enum Value { - A, - - B, - - UNKNOWN - } - - @Generated("com.palantir.conjure.java.types.EnumGenerator") - public interface Visitor { - T visitA(); - - T visitB(); - - T visitUnknown(String unknownValue); - - static AStageVisitorBuilder builder() { - return new VisitorBuilder(); - } - } - - private static final class VisitorBuilder - implements AStageVisitorBuilder, - BStageVisitorBuilder, - UnknownStageVisitorBuilder, - Completed_StageVisitorBuilder { - private Supplier aVisitor; - - private Supplier bVisitor; - - private Function<@Safe String, T> unknownVisitor; - - @Override - public BStageVisitorBuilder visitA(@Nonnull Supplier aVisitor) { - Preconditions.checkNotNull(aVisitor, "aVisitor cannot be null"); - this.aVisitor = aVisitor; - return this; - } - - @Override - public UnknownStageVisitorBuilder visitB(@Nonnull Supplier bVisitor) { - Preconditions.checkNotNull(bVisitor, "bVisitor cannot be null"); - this.bVisitor = bVisitor; - return this; - } - - @Override - public Completed_StageVisitorBuilder visitUnknown(@Nonnull Function<@Safe String, T> unknownVisitor) { - Preconditions.checkNotNull(unknownVisitor, "unknownVisitor cannot be null"); - this.unknownVisitor = unknownType -> unknownVisitor.apply(unknownType); - return this; - } - - @Override - public Completed_StageVisitorBuilder throwOnUnknown() { - this.unknownVisitor = unknownType -> { - throw new SafeIllegalArgumentException( - "Unknown variant of the 'EnumExample' union", SafeArg.of("unknownType", unknownType)); - }; - return this; - } - - @Override - public Visitor build() { - final Supplier aVisitor = this.aVisitor; - final Supplier bVisitor = this.bVisitor; - final Function<@Safe String, T> unknownVisitor = this.unknownVisitor; - return new Visitor() { - @Override - public T visitA() { - return aVisitor.get(); - } - - @Override - public T visitB() { - return bVisitor.get(); - } - - @Override - public T visitUnknown(String unknownType) { - return unknownVisitor.apply(unknownType); - } - }; - } - } - - public interface AStageVisitorBuilder { - BStageVisitorBuilder visitA(@Nonnull Supplier aVisitor); - } - - public interface BStageVisitorBuilder { - UnknownStageVisitorBuilder visitB(@Nonnull Supplier bVisitor); - } - - public interface UnknownStageVisitorBuilder { - Completed_StageVisitorBuilder visitUnknown(@Nonnull Function<@Safe String, T> unknownVisitor); - - Completed_StageVisitorBuilder throwOnUnknown(); - } - - public interface Completed_StageVisitorBuilder { - Visitor build(); - } -} diff --git a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/ExternalExample.java b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/ExternalExample.java deleted file mode 100644 index 4b45e6790..000000000 --- a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/ExternalExample.java +++ /dev/null @@ -1,183 +0,0 @@ -package jersey.com.palantir.product; - -import com.fasterxml.jackson.annotation.JsonIgnoreProperties; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.fasterxml.jackson.annotation.JsonSetter; -import com.fasterxml.jackson.annotation.Nulls; -import com.fasterxml.jackson.databind.annotation.JsonDeserialize; -import com.google.errorprone.annotations.CheckReturnValue; -import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.SafeArg; -import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; -import java.util.ArrayList; -import java.util.List; -import java.util.Optional; -import java.util.function.Function; -import javax.annotation.Nonnull; -import javax.annotation.Nullable; -import javax.annotation.processing.Generated; - -@JsonDeserialize(builder = ExternalExample.Builder.class) -@Generated("com.palantir.conjure.java.types.BeanGenerator") -public final class ExternalExample { - private final long externalLong; - - private final Optional optionalExternal; - - private int memoizedHashCode; - - private ExternalExample(long externalLong, Optional optionalExternal) { - validateFields(optionalExternal); - this.externalLong = externalLong; - this.optionalExternal = optionalExternal; - } - - @JsonProperty("externalLong") - public long getExternalLong() { - return this.externalLong; - } - - @JsonProperty("optionalExternal") - public Optional getOptionalExternal() { - return this.optionalExternal; - } - - @Override - public boolean equals(@Nullable Object other) { - return this == other || (other instanceof ExternalExample && equalTo((ExternalExample) other)); - } - - private boolean equalTo(ExternalExample other) { - if (this.memoizedHashCode != 0 - && other.memoizedHashCode != 0 - && this.memoizedHashCode != other.memoizedHashCode) { - return false; - } - return this.externalLong == other.externalLong && this.optionalExternal.equals(other.optionalExternal); - } - - @Override - public int hashCode() { - int result = memoizedHashCode; - if (result == 0) { - int hash = 1; - hash = 31 * hash + Long.hashCode(this.externalLong); - hash = 31 * hash + this.optionalExternal.hashCode(); - result = hash; - memoizedHashCode = result; - } - return result; - } - - @Override - public String toString() { - return "ExternalExample{externalLong: " + externalLong + ", optionalExternal: " + optionalExternal + '}'; - } - - public static ExternalExample of(long externalLong, long optionalExternal) { - return builder() - .externalLong(externalLong) - .optionalExternal(Optional.of(optionalExternal)) - .build(); - } - - private static void validateFields(Optional optionalExternal) { - List missingFields = null; - missingFields = addFieldIfMissing(missingFields, optionalExternal, "optionalExternal"); - if (missingFields != null) { - throw new SafeIllegalArgumentException( - "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); - } - } - - private static List addFieldIfMissing(List prev, Object fieldValue, String fieldName) { - List missingFields = prev; - if (fieldValue == null) { - if (missingFields == null) { - missingFields = new ArrayList<>(1); - } - missingFields.add(fieldName); - } - return missingFields; - } - - public static Builder builder() { - return new Builder(); - } - - @Generated("com.palantir.conjure.java.types.BeanBuilderGenerator") - @JsonIgnoreProperties(ignoreUnknown = true) - public static final class Builder { - boolean _buildInvoked; - - private long externalLong; - - private Optional optionalExternal = Optional.empty(); - - private boolean _externalLongInitialized = false; - - private Builder() {} - - public Builder from(ExternalExample other) { - checkNotBuilt(); - externalLong(other.getExternalLong()); - optionalExternal(other.getOptionalExternal()); - return this; - } - - @JsonSetter("externalLong") - public Builder externalLong(long externalLong) { - checkNotBuilt(); - this.externalLong = externalLong; - this._externalLongInitialized = true; - return this; - } - - @JsonSetter(value = "optionalExternal", nulls = Nulls.SKIP) - public Builder optionalExternal(@Nonnull Optional optionalExternal) { - checkNotBuilt(); - this.optionalExternal = Preconditions.checkNotNull(optionalExternal, "optionalExternal cannot be null") - .map(Function.identity()); - return this; - } - - public Builder optionalExternal(long optionalExternal) { - checkNotBuilt(); - this.optionalExternal = - Optional.of(Preconditions.checkNotNull(optionalExternal, "optionalExternal cannot be null")); - return this; - } - - private void validatePrimitiveFieldsHaveBeenInitialized() { - List missingFields = null; - missingFields = addFieldIfMissing(missingFields, _externalLongInitialized, "externalLong"); - if (missingFields != null) { - throw new SafeIllegalArgumentException( - "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); - } - } - - private static List addFieldIfMissing(List prev, boolean initialized, String fieldName) { - List missingFields = prev; - if (!initialized) { - if (missingFields == null) { - missingFields = new ArrayList<>(1); - } - missingFields.add(fieldName); - } - return missingFields; - } - - @CheckReturnValue - public ExternalExample build() { - checkNotBuilt(); - this._buildInvoked = true; - validatePrimitiveFieldsHaveBeenInitialized(); - return new ExternalExample(externalLong, optionalExternal); - } - - private void checkNotBuilt() { - Preconditions.checkState(!_buildInvoked, "Build has already been called"); - } - } -} diff --git a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/NestedAlias.java b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/NestedAlias.java deleted file mode 100644 index 04024beb9..000000000 --- a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/NestedAlias.java +++ /dev/null @@ -1,52 +0,0 @@ -package jersey.com.palantir.product; - -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonValue; -import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.Safe; -import javax.annotation.Nonnull; -import javax.annotation.Nullable; -import javax.annotation.processing.Generated; - -@Safe -@Generated("com.palantir.conjure.java.types.AliasGenerator") -public final class NestedAlias { - private final StringAliasEx value; - - private NestedAlias(@Nonnull StringAliasEx value) { - this.value = Preconditions.checkNotNull(value, "value cannot be null"); - } - - @JsonValue - public StringAliasEx get() { - return value; - } - - @Override - public String toString() { - return value.toString(); - } - - @Override - public boolean equals(@Nullable Object other) { - return this == other || (other instanceof NestedAlias && equalTo((NestedAlias) other)); - } - - private boolean equalTo(NestedAlias other) { - return this.value.equals(other.value); - } - - @Override - public int hashCode() { - return this.value.hashCode(); - } - - public static NestedAlias valueOf(@Safe String value) { - return of(StringAliasEx.valueOf(value)); - } - - @JsonCreator(mode = JsonCreator.Mode.DELEGATING) - public static NestedAlias of(@Nonnull StringAliasEx value) { - return new NestedAlias(value); - } -} diff --git a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/NestedCollectionExample.java b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/NestedCollectionExample.java deleted file mode 100644 index 9e64285c5..000000000 --- a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/NestedCollectionExample.java +++ /dev/null @@ -1,226 +0,0 @@ -package jersey.com.palantir.product; - -import com.fasterxml.jackson.annotation.JsonIgnoreProperties; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.fasterxml.jackson.annotation.JsonSetter; -import com.fasterxml.jackson.annotation.Nulls; -import com.fasterxml.jackson.databind.annotation.JsonDeserialize; -import com.google.errorprone.annotations.CheckReturnValue; -import com.palantir.conjure.java.lib.internal.ConjureCollections; -import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.SafeArg; -import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; -import java.util.ArrayList; -import java.util.Collections; -import java.util.LinkedHashMap; -import java.util.List; -import java.util.Map; -import javax.annotation.Nonnull; -import javax.annotation.Nullable; -import javax.annotation.processing.Generated; - -@JsonDeserialize(builder = NestedCollectionExample.Builder.class) -@Generated("com.palantir.conjure.java.types.BeanGenerator") -public final class NestedCollectionExample { - private final List> nestedList; - - private final Map> nestedMap; - - private final Map> mixedCollection; - - private int memoizedHashCode; - - private NestedCollectionExample( - List> nestedList, - Map> nestedMap, - Map> mixedCollection) { - validateFields(nestedList, nestedMap, mixedCollection); - this.nestedList = ConjureCollections.unmodifiableList(nestedList); - this.nestedMap = Collections.unmodifiableMap(nestedMap); - this.mixedCollection = Collections.unmodifiableMap(mixedCollection); - } - - @JsonProperty("nestedList") - public List> getNestedList() { - return this.nestedList; - } - - @JsonProperty("nestedMap") - public Map> getNestedMap() { - return this.nestedMap; - } - - @JsonProperty("mixedCollection") - public Map> getMixedCollection() { - return this.mixedCollection; - } - - @Override - public boolean equals(@Nullable Object other) { - return this == other || (other instanceof NestedCollectionExample && equalTo((NestedCollectionExample) other)); - } - - private boolean equalTo(NestedCollectionExample other) { - if (this.memoizedHashCode != 0 - && other.memoizedHashCode != 0 - && this.memoizedHashCode != other.memoizedHashCode) { - return false; - } - return this.nestedList.equals(other.nestedList) - && this.nestedMap.equals(other.nestedMap) - && this.mixedCollection.equals(other.mixedCollection); - } - - @Override - public int hashCode() { - int result = memoizedHashCode; - if (result == 0) { - int hash = 1; - hash = 31 * hash + this.nestedList.hashCode(); - hash = 31 * hash + this.nestedMap.hashCode(); - hash = 31 * hash + this.mixedCollection.hashCode(); - result = hash; - memoizedHashCode = result; - } - return result; - } - - @Override - public String toString() { - return "NestedCollectionExample{nestedList: " + nestedList + ", nestedMap: " + nestedMap + ", mixedCollection: " - + mixedCollection + '}'; - } - - public static NestedCollectionExample of( - List> nestedList, - Map> nestedMap, - Map> mixedCollection) { - return builder() - .nestedList(nestedList) - .nestedMap(nestedMap) - .mixedCollection(mixedCollection) - .build(); - } - - private static void validateFields( - List> nestedList, - Map> nestedMap, - Map> mixedCollection) { - List missingFields = null; - missingFields = addFieldIfMissing(missingFields, nestedList, "nestedList"); - missingFields = addFieldIfMissing(missingFields, nestedMap, "nestedMap"); - missingFields = addFieldIfMissing(missingFields, mixedCollection, "mixedCollection"); - if (missingFields != null) { - throw new SafeIllegalArgumentException( - "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); - } - } - - private static List addFieldIfMissing(List prev, Object fieldValue, String fieldName) { - List missingFields = prev; - if (fieldValue == null) { - if (missingFields == null) { - missingFields = new ArrayList<>(3); - } - missingFields.add(fieldName); - } - return missingFields; - } - - public static Builder builder() { - return new Builder(); - } - - @Generated("com.palantir.conjure.java.types.BeanBuilderGenerator") - @JsonIgnoreProperties(ignoreUnknown = true) - public static final class Builder { - boolean _buildInvoked; - - private List> nestedList = ConjureCollections.newList(); - - private Map> nestedMap = new LinkedHashMap<>(); - - private Map> mixedCollection = new LinkedHashMap<>(); - - private Builder() {} - - public Builder from(NestedCollectionExample other) { - checkNotBuilt(); - nestedList(other.getNestedList()); - nestedMap(other.getNestedMap()); - mixedCollection(other.getMixedCollection()); - return this; - } - - @JsonSetter(value = "nestedList", nulls = Nulls.SKIP) - public Builder nestedList(@Nonnull Iterable> nestedList) { - checkNotBuilt(); - this.nestedList = - ConjureCollections.newList(Preconditions.checkNotNull(nestedList, "nestedList cannot be null")); - return this; - } - - public Builder addAllNestedList(@Nonnull Iterable> nestedList) { - checkNotBuilt(); - ConjureCollections.addAll( - this.nestedList, Preconditions.checkNotNull(nestedList, "nestedList cannot be null")); - return this; - } - - public Builder nestedList(List nestedList) { - checkNotBuilt(); - this.nestedList.add(nestedList); - return this; - } - - @JsonSetter(value = "nestedMap", nulls = Nulls.SKIP) - public Builder nestedMap(@Nonnull Map> nestedMap) { - checkNotBuilt(); - this.nestedMap = new LinkedHashMap<>(Preconditions.checkNotNull(nestedMap, "nestedMap cannot be null")); - return this; - } - - public Builder putAllNestedMap(@Nonnull Map> nestedMap) { - checkNotBuilt(); - this.nestedMap.putAll(Preconditions.checkNotNull(nestedMap, "nestedMap cannot be null")); - return this; - } - - public Builder nestedMap(String key, Map value) { - checkNotBuilt(); - this.nestedMap.put(key, value); - return this; - } - - @JsonSetter(value = "mixedCollection", nulls = Nulls.SKIP) - public Builder mixedCollection(@Nonnull Map> mixedCollection) { - checkNotBuilt(); - this.mixedCollection = - new LinkedHashMap<>(Preconditions.checkNotNull(mixedCollection, "mixedCollection cannot be null")); - return this; - } - - public Builder putAllMixedCollection(@Nonnull Map> mixedCollection) { - checkNotBuilt(); - this.mixedCollection.putAll(Preconditions.checkNotNull(mixedCollection, "mixedCollection cannot be null")); - return this; - } - - public Builder mixedCollection(String key, List value) { - checkNotBuilt(); - this.mixedCollection.put(key, value); - return this; - } - - @CheckReturnValue - public NestedCollectionExample build() { - checkNotBuilt(); - this._buildInvoked = true; - return new NestedCollectionExample(nestedList, nestedMap, mixedCollection); - } - - private void checkNotBuilt() { - Preconditions.checkState(!_buildInvoked, "Build has already been called"); - } - } -} diff --git a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/ObjectReference.java b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/ObjectReference.java deleted file mode 100644 index 4d0b4b9d0..000000000 --- a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/ObjectReference.java +++ /dev/null @@ -1,169 +0,0 @@ -package jersey.com.palantir.product; - -import com.fasterxml.jackson.annotation.JsonIgnoreProperties; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.fasterxml.jackson.annotation.JsonSetter; -import com.fasterxml.jackson.databind.annotation.JsonDeserialize; -import com.google.errorprone.annotations.CheckReturnValue; -import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.SafeArg; -import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; -import java.util.ArrayList; -import java.util.List; -import javax.annotation.Nonnull; -import javax.annotation.Nullable; -import javax.annotation.processing.Generated; - -@JsonDeserialize(builder = ObjectReference.Builder.class) -@Generated("com.palantir.conjure.java.types.BeanGenerator") -public final class ObjectReference { - private final String name; - - private final int value; - - private int memoizedHashCode; - - private ObjectReference(String name, int value) { - validateFields(name); - this.name = name; - this.value = value; - } - - @JsonProperty("name") - public String getName() { - return this.name; - } - - @JsonProperty("value") - public int getValue() { - return this.value; - } - - @Override - public boolean equals(@Nullable Object other) { - return this == other || (other instanceof ObjectReference && equalTo((ObjectReference) other)); - } - - private boolean equalTo(ObjectReference other) { - if (this.memoizedHashCode != 0 - && other.memoizedHashCode != 0 - && this.memoizedHashCode != other.memoizedHashCode) { - return false; - } - return this.name.equals(other.name) && this.value == other.value; - } - - @Override - public int hashCode() { - int result = memoizedHashCode; - if (result == 0) { - int hash = 1; - hash = 31 * hash + this.name.hashCode(); - hash = 31 * hash + this.value; - result = hash; - memoizedHashCode = result; - } - return result; - } - - @Override - public String toString() { - return "ObjectReference{name: " + name + ", value: " + value + '}'; - } - - public static ObjectReference of(String name, int value) { - return builder().name(name).value(value).build(); - } - - private static void validateFields(String name) { - List missingFields = null; - missingFields = addFieldIfMissing(missingFields, name, "name"); - if (missingFields != null) { - throw new SafeIllegalArgumentException( - "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); - } - } - - private static List addFieldIfMissing(List prev, Object fieldValue, String fieldName) { - List missingFields = prev; - if (fieldValue == null) { - if (missingFields == null) { - missingFields = new ArrayList<>(1); - } - missingFields.add(fieldName); - } - return missingFields; - } - - public static Builder builder() { - return new Builder(); - } - - @Generated("com.palantir.conjure.java.types.BeanBuilderGenerator") - @JsonIgnoreProperties(ignoreUnknown = true) - public static final class Builder { - boolean _buildInvoked; - - private String name; - - private int value; - - private boolean _valueInitialized = false; - - private Builder() {} - - public Builder from(ObjectReference other) { - checkNotBuilt(); - name(other.getName()); - value(other.getValue()); - return this; - } - - @JsonSetter("name") - public Builder name(@Nonnull String name) { - checkNotBuilt(); - this.name = Preconditions.checkNotNull(name, "name cannot be null"); - return this; - } - - @JsonSetter("value") - public Builder value(int value) { - checkNotBuilt(); - this.value = value; - this._valueInitialized = true; - return this; - } - - private void validatePrimitiveFieldsHaveBeenInitialized() { - List missingFields = null; - missingFields = addFieldIfMissing(missingFields, _valueInitialized, "value"); - if (missingFields != null) { - throw new SafeIllegalArgumentException( - "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); - } - } - - private static List addFieldIfMissing(List prev, boolean initialized, String fieldName) { - List missingFields = prev; - if (!initialized) { - if (missingFields == null) { - missingFields = new ArrayList<>(1); - } - missingFields.add(fieldName); - } - return missingFields; - } - - @CheckReturnValue - public ObjectReference build() { - checkNotBuilt(); - this._buildInvoked = true; - validatePrimitiveFieldsHaveBeenInitialized(); - return new ObjectReference(name, value); - } - - private void checkNotBuilt() { - Preconditions.checkState(!_buildInvoked, "Build has already been called"); - } - } -} diff --git a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/OptionalAlias.java b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/OptionalAlias.java deleted file mode 100644 index e0a954b10..000000000 --- a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/OptionalAlias.java +++ /dev/null @@ -1,60 +0,0 @@ -package jersey.com.palantir.product; - -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonValue; -import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.Safe; -import java.util.Optional; -import javax.annotation.Nonnull; -import javax.annotation.Nullable; -import javax.annotation.processing.Generated; - -@Safe -@Generated("com.palantir.conjure.java.types.AliasGenerator") -public final class OptionalAlias { - private static final OptionalAlias EMPTY = new OptionalAlias(); - - private final Optional<@Safe String> value; - - private OptionalAlias(@Nonnull Optional<@Safe String> value) { - this.value = Preconditions.checkNotNull(value, "value cannot be null"); - } - - private OptionalAlias() { - this(Optional.empty()); - } - - @JsonValue - public Optional<@Safe String> get() { - return value; - } - - @Override - @Safe - public String toString() { - return value.toString(); - } - - @Override - public boolean equals(@Nullable Object other) { - return this == other || (other instanceof OptionalAlias && equalTo((OptionalAlias) other)); - } - - private boolean equalTo(OptionalAlias other) { - return this.value.equals(other.value); - } - - @Override - public int hashCode() { - return this.value.hashCode(); - } - - @JsonCreator(mode = JsonCreator.Mode.DELEGATING) - public static OptionalAlias of(@Nonnull Optional<@Safe String> value) { - return new OptionalAlias(value); - } - - public static OptionalAlias empty() { - return EMPTY; - } -} diff --git a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/OptionalExample.java b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/OptionalExample.java deleted file mode 100644 index 855c1d847..000000000 --- a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/OptionalExample.java +++ /dev/null @@ -1,206 +0,0 @@ -package jersey.com.palantir.product; - -import com.fasterxml.jackson.annotation.JsonIgnoreProperties; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.fasterxml.jackson.annotation.JsonSetter; -import com.fasterxml.jackson.annotation.Nulls; -import com.fasterxml.jackson.databind.annotation.JsonDeserialize; -import com.google.errorprone.annotations.CheckReturnValue; -import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.SafeArg; -import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; -import java.util.ArrayList; -import java.util.List; -import java.util.Optional; -import java.util.function.Function; -import javax.annotation.Nonnull; -import javax.annotation.Nullable; -import javax.annotation.processing.Generated; - -@JsonDeserialize(builder = OptionalExample.Builder.class) -@Generated("com.palantir.conjure.java.types.BeanGenerator") -public final class OptionalExample { - private final Optional optionalString; - - private final Optional optionalObject; - - private final Optional> optionalCollection; - - private int memoizedHashCode; - - private OptionalExample( - Optional optionalString, - Optional optionalObject, - Optional> optionalCollection) { - validateFields(optionalString, optionalObject, optionalCollection); - this.optionalString = optionalString; - this.optionalObject = optionalObject; - this.optionalCollection = optionalCollection; - } - - @JsonProperty("optionalString") - public Optional getOptionalString() { - return this.optionalString; - } - - @JsonProperty("optionalObject") - public Optional getOptionalObject() { - return this.optionalObject; - } - - @JsonProperty("optionalCollection") - public Optional> getOptionalCollection() { - return this.optionalCollection; - } - - @Override - public boolean equals(@Nullable Object other) { - return this == other || (other instanceof OptionalExample && equalTo((OptionalExample) other)); - } - - private boolean equalTo(OptionalExample other) { - if (this.memoizedHashCode != 0 - && other.memoizedHashCode != 0 - && this.memoizedHashCode != other.memoizedHashCode) { - return false; - } - return this.optionalString.equals(other.optionalString) - && this.optionalObject.equals(other.optionalObject) - && this.optionalCollection.equals(other.optionalCollection); - } - - @Override - public int hashCode() { - int result = memoizedHashCode; - if (result == 0) { - int hash = 1; - hash = 31 * hash + this.optionalString.hashCode(); - hash = 31 * hash + this.optionalObject.hashCode(); - hash = 31 * hash + this.optionalCollection.hashCode(); - result = hash; - memoizedHashCode = result; - } - return result; - } - - @Override - public String toString() { - return "OptionalExample{optionalString: " + optionalString + ", optionalObject: " + optionalObject - + ", optionalCollection: " + optionalCollection + '}'; - } - - public static OptionalExample of( - String optionalString, ObjectReference optionalObject, List optionalCollection) { - return builder() - .optionalString(Optional.of(optionalString)) - .optionalObject(Optional.of(optionalObject)) - .optionalCollection(Optional.of(optionalCollection)) - .build(); - } - - private static void validateFields( - Optional optionalString, - Optional optionalObject, - Optional> optionalCollection) { - List missingFields = null; - missingFields = addFieldIfMissing(missingFields, optionalString, "optionalString"); - missingFields = addFieldIfMissing(missingFields, optionalObject, "optionalObject"); - missingFields = addFieldIfMissing(missingFields, optionalCollection, "optionalCollection"); - if (missingFields != null) { - throw new SafeIllegalArgumentException( - "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); - } - } - - private static List addFieldIfMissing(List prev, Object fieldValue, String fieldName) { - List missingFields = prev; - if (fieldValue == null) { - if (missingFields == null) { - missingFields = new ArrayList<>(3); - } - missingFields.add(fieldName); - } - return missingFields; - } - - public static Builder builder() { - return new Builder(); - } - - @Generated("com.palantir.conjure.java.types.BeanBuilderGenerator") - @JsonIgnoreProperties(ignoreUnknown = true) - public static final class Builder { - boolean _buildInvoked; - - private Optional optionalString = Optional.empty(); - - private Optional optionalObject = Optional.empty(); - - private Optional> optionalCollection = Optional.empty(); - - private Builder() {} - - public Builder from(OptionalExample other) { - checkNotBuilt(); - optionalString(other.getOptionalString()); - optionalObject(other.getOptionalObject()); - optionalCollection(other.getOptionalCollection()); - return this; - } - - @JsonSetter(value = "optionalString", nulls = Nulls.SKIP) - public Builder optionalString(@Nonnull Optional optionalString) { - checkNotBuilt(); - this.optionalString = Preconditions.checkNotNull(optionalString, "optionalString cannot be null"); - return this; - } - - public Builder optionalString(@Nonnull String optionalString) { - checkNotBuilt(); - this.optionalString = - Optional.of(Preconditions.checkNotNull(optionalString, "optionalString cannot be null")); - return this; - } - - @JsonSetter(value = "optionalObject", nulls = Nulls.SKIP) - public Builder optionalObject(@Nonnull Optional optionalObject) { - checkNotBuilt(); - this.optionalObject = Preconditions.checkNotNull(optionalObject, "optionalObject cannot be null"); - return this; - } - - public Builder optionalObject(@Nonnull ObjectReference optionalObject) { - checkNotBuilt(); - this.optionalObject = - Optional.of(Preconditions.checkNotNull(optionalObject, "optionalObject cannot be null")); - return this; - } - - @JsonSetter(value = "optionalCollection", nulls = Nulls.SKIP) - public Builder optionalCollection(@Nonnull Optional> optionalCollection) { - checkNotBuilt(); - this.optionalCollection = Preconditions.checkNotNull( - optionalCollection, "optionalCollection cannot be null") - .map(Function.identity()); - return this; - } - - public Builder optionalCollection(@Nonnull List optionalCollection) { - checkNotBuilt(); - this.optionalCollection = - Optional.of(Preconditions.checkNotNull(optionalCollection, "optionalCollection cannot be null")); - return this; - } - - @CheckReturnValue - public OptionalExample build() { - checkNotBuilt(); - this._buildInvoked = true; - return new OptionalExample(optionalString, optionalObject, optionalCollection); - } - - private void checkNotBuilt() { - Preconditions.checkState(!_buildInvoked, "Build has already been called"); - } - } -} diff --git a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/PrimitiveExample.java b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/PrimitiveExample.java deleted file mode 100644 index 000257feb..000000000 --- a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/PrimitiveExample.java +++ /dev/null @@ -1,345 +0,0 @@ -package jersey.com.palantir.product; - -import com.fasterxml.jackson.annotation.JsonIgnoreProperties; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.fasterxml.jackson.annotation.JsonSetter; -import com.fasterxml.jackson.databind.annotation.JsonDeserialize; -import com.google.errorprone.annotations.CheckReturnValue; -import com.palantir.conjure.java.lib.SafeLong; -import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.SafeArg; -import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; -import com.palantir.ri.ResourceIdentifier; -import java.nio.Buffer; -import java.nio.ByteBuffer; -import java.time.OffsetDateTime; -import java.util.ArrayList; -import java.util.List; -import java.util.UUID; -import javax.annotation.Nonnull; -import javax.annotation.Nullable; -import javax.annotation.processing.Generated; - -@JsonDeserialize(builder = PrimitiveExample.Builder.class) -@Generated("com.palantir.conjure.java.types.BeanGenerator") -public final class PrimitiveExample { - private final String stringVal; - - private final int intVal; - - private final SafeLong longVal; - - private final double doubleVal; - - private final boolean boolVal; - - private final ResourceIdentifier ridVal; - - private final UUID uuidVal; - - private final OffsetDateTime datetimeVal; - - private final ByteBuffer binaryVal; - - private int memoizedHashCode; - - private PrimitiveExample( - String stringVal, - int intVal, - SafeLong longVal, - double doubleVal, - boolean boolVal, - ResourceIdentifier ridVal, - UUID uuidVal, - OffsetDateTime datetimeVal, - ByteBuffer binaryVal) { - validateFields(stringVal, longVal, ridVal, uuidVal, datetimeVal, binaryVal); - this.stringVal = stringVal; - this.intVal = intVal; - this.longVal = longVal; - this.doubleVal = doubleVal; - this.boolVal = boolVal; - this.ridVal = ridVal; - this.uuidVal = uuidVal; - this.datetimeVal = datetimeVal; - this.binaryVal = binaryVal; - } - - @JsonProperty("stringVal") - public String getStringVal() { - return this.stringVal; - } - - @JsonProperty("intVal") - public int getIntVal() { - return this.intVal; - } - - @JsonProperty("longVal") - public SafeLong getLongVal() { - return this.longVal; - } - - @JsonProperty("doubleVal") - public double getDoubleVal() { - return this.doubleVal; - } - - @JsonProperty("boolVal") - public boolean getBoolVal() { - return this.boolVal; - } - - @JsonProperty("ridVal") - public ResourceIdentifier getRidVal() { - return this.ridVal; - } - - @JsonProperty("uuidVal") - public UUID getUuidVal() { - return this.uuidVal; - } - - @JsonProperty("datetimeVal") - public OffsetDateTime getDatetimeVal() { - return this.datetimeVal; - } - - @JsonProperty("binaryVal") - public ByteBuffer getBinaryVal() { - return this.binaryVal.asReadOnlyBuffer(); - } - - @Override - public boolean equals(@Nullable Object other) { - return this == other || (other instanceof PrimitiveExample && equalTo((PrimitiveExample) other)); - } - - private boolean equalTo(PrimitiveExample other) { - if (this.memoizedHashCode != 0 - && other.memoizedHashCode != 0 - && this.memoizedHashCode != other.memoizedHashCode) { - return false; - } - return this.stringVal.equals(other.stringVal) - && this.intVal == other.intVal - && this.longVal.equals(other.longVal) - && Double.doubleToLongBits(this.doubleVal) == Double.doubleToLongBits(other.doubleVal) - && this.boolVal == other.boolVal - && this.ridVal.equals(other.ridVal) - && this.uuidVal.equals(other.uuidVal) - && this.datetimeVal.isEqual(other.datetimeVal) - && this.binaryVal.equals(other.binaryVal); - } - - @Override - public int hashCode() { - int result = memoizedHashCode; - if (result == 0) { - int hash = 1; - hash = 31 * hash + this.stringVal.hashCode(); - hash = 31 * hash + this.intVal; - hash = 31 * hash + this.longVal.hashCode(); - hash = 31 * hash + Double.hashCode(this.doubleVal); - hash = 31 * hash + Boolean.hashCode(this.boolVal); - hash = 31 * hash + this.ridVal.hashCode(); - hash = 31 * hash + this.uuidVal.hashCode(); - hash = 31 * hash + this.datetimeVal.toInstant().hashCode(); - hash = 31 * hash + this.binaryVal.hashCode(); - result = hash; - memoizedHashCode = result; - } - return result; - } - - @Override - public String toString() { - return "PrimitiveExample{stringVal: " + stringVal + ", intVal: " + intVal + ", longVal: " + longVal - + ", doubleVal: " + doubleVal + ", boolVal: " + boolVal + ", ridVal: " + ridVal + ", uuidVal: " - + uuidVal + ", datetimeVal: " + datetimeVal + ", binaryVal: " + binaryVal + '}'; - } - - private static void validateFields( - String stringVal, - SafeLong longVal, - ResourceIdentifier ridVal, - UUID uuidVal, - OffsetDateTime datetimeVal, - ByteBuffer binaryVal) { - List missingFields = null; - missingFields = addFieldIfMissing(missingFields, stringVal, "stringVal"); - missingFields = addFieldIfMissing(missingFields, longVal, "longVal"); - missingFields = addFieldIfMissing(missingFields, ridVal, "ridVal"); - missingFields = addFieldIfMissing(missingFields, uuidVal, "uuidVal"); - missingFields = addFieldIfMissing(missingFields, datetimeVal, "datetimeVal"); - missingFields = addFieldIfMissing(missingFields, binaryVal, "binaryVal"); - if (missingFields != null) { - throw new SafeIllegalArgumentException( - "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); - } - } - - private static List addFieldIfMissing(List prev, Object fieldValue, String fieldName) { - List missingFields = prev; - if (fieldValue == null) { - if (missingFields == null) { - missingFields = new ArrayList<>(6); - } - missingFields.add(fieldName); - } - return missingFields; - } - - public static Builder builder() { - return new Builder(); - } - - @Generated("com.palantir.conjure.java.types.BeanBuilderGenerator") - @JsonIgnoreProperties(ignoreUnknown = true) - public static final class Builder { - boolean _buildInvoked; - - private String stringVal; - - private int intVal; - - private SafeLong longVal; - - private double doubleVal; - - private boolean boolVal; - - private ResourceIdentifier ridVal; - - private UUID uuidVal; - - private OffsetDateTime datetimeVal; - - private ByteBuffer binaryVal; - - private boolean _intValInitialized = false; - - private boolean _doubleValInitialized = false; - - private boolean _boolValInitialized = false; - - private Builder() {} - - public Builder from(PrimitiveExample other) { - checkNotBuilt(); - stringVal(other.getStringVal()); - intVal(other.getIntVal()); - longVal(other.getLongVal()); - doubleVal(other.getDoubleVal()); - boolVal(other.getBoolVal()); - ridVal(other.getRidVal()); - uuidVal(other.getUuidVal()); - datetimeVal(other.getDatetimeVal()); - binaryVal(other.getBinaryVal()); - return this; - } - - @JsonSetter("stringVal") - public Builder stringVal(@Nonnull String stringVal) { - checkNotBuilt(); - this.stringVal = Preconditions.checkNotNull(stringVal, "stringVal cannot be null"); - return this; - } - - @JsonSetter("intVal") - public Builder intVal(int intVal) { - checkNotBuilt(); - this.intVal = intVal; - this._intValInitialized = true; - return this; - } - - @JsonSetter("longVal") - public Builder longVal(@Nonnull SafeLong longVal) { - checkNotBuilt(); - this.longVal = Preconditions.checkNotNull(longVal, "longVal cannot be null"); - return this; - } - - @JsonSetter("doubleVal") - public Builder doubleVal(double doubleVal) { - checkNotBuilt(); - this.doubleVal = doubleVal; - this._doubleValInitialized = true; - return this; - } - - @JsonSetter("boolVal") - public Builder boolVal(boolean boolVal) { - checkNotBuilt(); - this.boolVal = boolVal; - this._boolValInitialized = true; - return this; - } - - @JsonSetter("ridVal") - public Builder ridVal(@Nonnull ResourceIdentifier ridVal) { - checkNotBuilt(); - this.ridVal = Preconditions.checkNotNull(ridVal, "ridVal cannot be null"); - return this; - } - - @JsonSetter("uuidVal") - public Builder uuidVal(@Nonnull UUID uuidVal) { - checkNotBuilt(); - this.uuidVal = Preconditions.checkNotNull(uuidVal, "uuidVal cannot be null"); - return this; - } - - @JsonSetter("datetimeVal") - public Builder datetimeVal(@Nonnull OffsetDateTime datetimeVal) { - checkNotBuilt(); - this.datetimeVal = Preconditions.checkNotNull(datetimeVal, "datetimeVal cannot be null"); - return this; - } - - @JsonSetter("binaryVal") - public Builder binaryVal(@Nonnull ByteBuffer binaryVal) { - checkNotBuilt(); - Preconditions.checkNotNull(binaryVal, "binaryVal cannot be null"); - this.binaryVal = ByteBuffer.allocate(binaryVal.remaining()).put(binaryVal.duplicate()); - ((Buffer) this.binaryVal).rewind(); - return this; - } - - private void validatePrimitiveFieldsHaveBeenInitialized() { - List missingFields = null; - missingFields = addFieldIfMissing(missingFields, _intValInitialized, "intVal"); - missingFields = addFieldIfMissing(missingFields, _doubleValInitialized, "doubleVal"); - missingFields = addFieldIfMissing(missingFields, _boolValInitialized, "boolVal"); - if (missingFields != null) { - throw new SafeIllegalArgumentException( - "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); - } - } - - private static List addFieldIfMissing(List prev, boolean initialized, String fieldName) { - List missingFields = prev; - if (!initialized) { - if (missingFields == null) { - missingFields = new ArrayList<>(3); - } - missingFields.add(fieldName); - } - return missingFields; - } - - @CheckReturnValue - public PrimitiveExample build() { - checkNotBuilt(); - this._buildInvoked = true; - validatePrimitiveFieldsHaveBeenInitialized(); - return new PrimitiveExample( - stringVal, intVal, longVal, doubleVal, boolVal, ridVal, uuidVal, datetimeVal, binaryVal); - } - - private void checkNotBuilt() { - Preconditions.checkState(!_buildInvoked, "Build has already been called"); - } - } -} diff --git a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/SafetyExample.java b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/SafetyExample.java deleted file mode 100644 index cf44cb5d0..000000000 --- a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/SafetyExample.java +++ /dev/null @@ -1,176 +0,0 @@ -package jersey.com.palantir.product; - -import com.fasterxml.jackson.annotation.JsonIgnoreProperties; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.fasterxml.jackson.annotation.JsonSetter; -import com.fasterxml.jackson.databind.annotation.JsonDeserialize; -import com.google.errorprone.annotations.CheckReturnValue; -import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.Safe; -import com.palantir.logsafe.SafeArg; -import com.palantir.logsafe.Unsafe; -import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; -import java.util.ArrayList; -import java.util.List; -import javax.annotation.Nonnull; -import javax.annotation.Nullable; -import javax.annotation.processing.Generated; - -@Unsafe -@JsonDeserialize(builder = SafetyExample.Builder.class) -@Generated("com.palantir.conjure.java.types.BeanGenerator") -public final class SafetyExample { - private final String safeString; - - private final double unsafeDouble; - - private int memoizedHashCode; - - private SafetyExample(String safeString, double unsafeDouble) { - validateFields(safeString); - this.safeString = safeString; - this.unsafeDouble = unsafeDouble; - } - - @JsonProperty("safeString") - @Safe - public String getSafeString() { - return this.safeString; - } - - @JsonProperty("unsafeDouble") - @Unsafe - public double getUnsafeDouble() { - return this.unsafeDouble; - } - - @Override - public boolean equals(@Nullable Object other) { - return this == other || (other instanceof SafetyExample && equalTo((SafetyExample) other)); - } - - private boolean equalTo(SafetyExample other) { - if (this.memoizedHashCode != 0 - && other.memoizedHashCode != 0 - && this.memoizedHashCode != other.memoizedHashCode) { - return false; - } - return this.safeString.equals(other.safeString) - && Double.doubleToLongBits(this.unsafeDouble) == Double.doubleToLongBits(other.unsafeDouble); - } - - @Override - public int hashCode() { - int result = memoizedHashCode; - if (result == 0) { - int hash = 1; - hash = 31 * hash + this.safeString.hashCode(); - hash = 31 * hash + Double.hashCode(this.unsafeDouble); - result = hash; - memoizedHashCode = result; - } - return result; - } - - @Override - @Unsafe - public String toString() { - return "SafetyExample{safeString: " + safeString + ", unsafeDouble: " + unsafeDouble + '}'; - } - - public static SafetyExample of(@Safe String safeString, @Unsafe double unsafeDouble) { - return builder().safeString(safeString).unsafeDouble(unsafeDouble).build(); - } - - private static void validateFields(String safeString) { - List missingFields = null; - missingFields = addFieldIfMissing(missingFields, safeString, "safeString"); - if (missingFields != null) { - throw new SafeIllegalArgumentException( - "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); - } - } - - private static List addFieldIfMissing(List prev, Object fieldValue, String fieldName) { - List missingFields = prev; - if (fieldValue == null) { - if (missingFields == null) { - missingFields = new ArrayList<>(1); - } - missingFields.add(fieldName); - } - return missingFields; - } - - public static Builder builder() { - return new Builder(); - } - - @Generated("com.palantir.conjure.java.types.BeanBuilderGenerator") - @JsonIgnoreProperties(ignoreUnknown = true) - public static final class Builder { - boolean _buildInvoked; - - private @Safe String safeString; - - private @Unsafe double unsafeDouble; - - private boolean _unsafeDoubleInitialized = false; - - private Builder() {} - - public Builder from(SafetyExample other) { - checkNotBuilt(); - safeString(other.getSafeString()); - unsafeDouble(other.getUnsafeDouble()); - return this; - } - - @JsonSetter("safeString") - public Builder safeString(@Nonnull @Safe String safeString) { - checkNotBuilt(); - this.safeString = Preconditions.checkNotNull(safeString, "safeString cannot be null"); - return this; - } - - @JsonSetter("unsafeDouble") - public Builder unsafeDouble(@Unsafe double unsafeDouble) { - checkNotBuilt(); - this.unsafeDouble = unsafeDouble; - this._unsafeDoubleInitialized = true; - return this; - } - - private void validatePrimitiveFieldsHaveBeenInitialized() { - List missingFields = null; - missingFields = addFieldIfMissing(missingFields, _unsafeDoubleInitialized, "unsafeDouble"); - if (missingFields != null) { - throw new SafeIllegalArgumentException( - "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); - } - } - - private static List addFieldIfMissing(List prev, boolean initialized, String fieldName) { - List missingFields = prev; - if (!initialized) { - if (missingFields == null) { - missingFields = new ArrayList<>(1); - } - missingFields.add(fieldName); - } - return missingFields; - } - - @CheckReturnValue - public SafetyExample build() { - checkNotBuilt(); - this._buildInvoked = true; - validatePrimitiveFieldsHaveBeenInitialized(); - return new SafetyExample(safeString, unsafeDouble); - } - - private void checkNotBuilt() { - Preconditions.checkState(!_buildInvoked, "Build has already been called"); - } - } -} diff --git a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/StringAliasEx.java b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/StringAliasEx.java deleted file mode 100644 index d979fb1f2..000000000 --- a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/StringAliasEx.java +++ /dev/null @@ -1,58 +0,0 @@ -package jersey.com.palantir.product; - -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonValue; -import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.Safe; -import javax.annotation.Nonnull; -import javax.annotation.Nullable; -import javax.annotation.processing.Generated; - -@Safe -@Generated("com.palantir.conjure.java.types.AliasGenerator") -public final class StringAliasEx implements Comparable { - private final @Safe String value; - - private StringAliasEx(@Nonnull @Safe String value) { - this.value = Preconditions.checkNotNull(value, "value cannot be null"); - } - - @JsonValue - public @Safe String get() { - return value; - } - - @Override - @Safe - public String toString() { - return value.toString(); - } - - @Override - public boolean equals(@Nullable Object other) { - return this == other || (other instanceof StringAliasEx && equalTo((StringAliasEx) other)); - } - - private boolean equalTo(StringAliasEx other) { - return this.value.equals(other.value); - } - - @Override - public int hashCode() { - return this.value.hashCode(); - } - - @Override - public int compareTo(StringAliasEx other) { - return value.compareTo(other.get()); - } - - public static StringAliasEx valueOf(@Safe String value) { - return of(value); - } - - @JsonCreator(mode = JsonCreator.Mode.DELEGATING) - public static StringAliasEx of(@Nonnull @Safe String value) { - return new StringAliasEx(value); - } -} diff --git a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/UnionExample.java b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/UnionExample.java deleted file mode 100644 index 02dc9e822..000000000 --- a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/UnionExample.java +++ /dev/null @@ -1,579 +0,0 @@ -package jersey.com.palantir.product; - -import com.fasterxml.jackson.annotation.JsonAnyGetter; -import com.fasterxml.jackson.annotation.JsonAnySetter; -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonIgnoreProperties; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.fasterxml.jackson.annotation.JsonSetter; -import com.fasterxml.jackson.annotation.JsonSubTypes; -import com.fasterxml.jackson.annotation.JsonTypeInfo; -import com.fasterxml.jackson.annotation.JsonTypeName; -import com.fasterxml.jackson.annotation.JsonValue; -import com.fasterxml.jackson.annotation.Nulls; -import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.Safe; -import com.palantir.logsafe.SafeArg; -import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.Optional; -import java.util.function.Function; -import java.util.function.IntFunction; -import javax.annotation.Nonnull; -import javax.annotation.Nullable; -import javax.annotation.processing.Generated; - -@Generated("com.palantir.conjure.java.types.UnionGenerator") -public final class UnionExample { - private final Base value; - - @JsonCreator(mode = JsonCreator.Mode.DELEGATING) - private UnionExample(Base value) { - this.value = value; - } - - @JsonValue - private Base getValue() { - return value; - } - - public static UnionExample stringVariant(String value) { - return new UnionExample(new StringVariantWrapper(value)); - } - - public static UnionExample intVariant(int value) { - return new UnionExample(new IntVariantWrapper(value)); - } - - public static UnionExample objectVariant(ObjectReference value) { - return new UnionExample(new ObjectVariantWrapper(value)); - } - - public static UnionExample collectionVariant(List value) { - return new UnionExample(new CollectionVariantWrapper(value)); - } - - public static UnionExample optionalVariant(Optional value) { - return new UnionExample(new OptionalVariantWrapper(value)); - } - - public static UnionExample unknown(@Safe String type, Object value) { - switch (Preconditions.checkNotNull(type, "Type is required")) { - case "stringVariant": - throw new SafeIllegalArgumentException( - "Unknown type cannot be created as the provided type is known: stringVariant"); - case "intVariant": - throw new SafeIllegalArgumentException( - "Unknown type cannot be created as the provided type is known: intVariant"); - case "objectVariant": - throw new SafeIllegalArgumentException( - "Unknown type cannot be created as the provided type is known: objectVariant"); - case "collectionVariant": - throw new SafeIllegalArgumentException( - "Unknown type cannot be created as the provided type is known: collectionVariant"); - case "optionalVariant": - throw new SafeIllegalArgumentException( - "Unknown type cannot be created as the provided type is known: optionalVariant"); - default: - return new UnionExample(new UnknownWrapper(type, Collections.singletonMap(type, value))); - } - } - - public T accept(Visitor visitor) { - return value.accept(visitor); - } - - @Override - public boolean equals(@Nullable Object other) { - return this == other || (other instanceof UnionExample && equalTo((UnionExample) other)); - } - - private boolean equalTo(UnionExample other) { - return this.value.equals(other.value); - } - - @Override - public int hashCode() { - return this.value.hashCode(); - } - - @Override - public String toString() { - return "UnionExample{value: " + value + '}'; - } - - public interface Visitor { - T visitStringVariant(String value); - - T visitIntVariant(int value); - - T visitObjectVariant(ObjectReference value); - - T visitCollectionVariant(List value); - - T visitOptionalVariant(Optional value); - - T visitUnknown(@Safe String unknownType); - - static CollectionVariantStageVisitorBuilder builder() { - return new VisitorBuilder(); - } - } - - private static final class VisitorBuilder - implements CollectionVariantStageVisitorBuilder, - IntVariantStageVisitorBuilder, - ObjectVariantStageVisitorBuilder, - OptionalVariantStageVisitorBuilder, - StringVariantStageVisitorBuilder, - UnknownStageVisitorBuilder, - Completed_StageVisitorBuilder { - private Function, T> collectionVariantVisitor; - - private IntFunction intVariantVisitor; - - private Function objectVariantVisitor; - - private Function, T> optionalVariantVisitor; - - private Function stringVariantVisitor; - - private Function unknownVisitor; - - @Override - public IntVariantStageVisitorBuilder collectionVariant( - @Nonnull Function, T> collectionVariantVisitor) { - Preconditions.checkNotNull(collectionVariantVisitor, "collectionVariantVisitor cannot be null"); - this.collectionVariantVisitor = collectionVariantVisitor; - return this; - } - - @Override - public ObjectVariantStageVisitorBuilder intVariant(@Nonnull IntFunction intVariantVisitor) { - Preconditions.checkNotNull(intVariantVisitor, "intVariantVisitor cannot be null"); - this.intVariantVisitor = intVariantVisitor; - return this; - } - - @Override - public OptionalVariantStageVisitorBuilder objectVariant( - @Nonnull Function objectVariantVisitor) { - Preconditions.checkNotNull(objectVariantVisitor, "objectVariantVisitor cannot be null"); - this.objectVariantVisitor = objectVariantVisitor; - return this; - } - - @Override - public StringVariantStageVisitorBuilder optionalVariant( - @Nonnull Function, T> optionalVariantVisitor) { - Preconditions.checkNotNull(optionalVariantVisitor, "optionalVariantVisitor cannot be null"); - this.optionalVariantVisitor = optionalVariantVisitor; - return this; - } - - @Override - public UnknownStageVisitorBuilder stringVariant(@Nonnull Function stringVariantVisitor) { - Preconditions.checkNotNull(stringVariantVisitor, "stringVariantVisitor cannot be null"); - this.stringVariantVisitor = stringVariantVisitor; - return this; - } - - @Override - public Completed_StageVisitorBuilder unknown(@Nonnull Function unknownVisitor) { - Preconditions.checkNotNull(unknownVisitor, "unknownVisitor cannot be null"); - this.unknownVisitor = unknownVisitor; - return this; - } - - @Override - public Completed_StageVisitorBuilder throwOnUnknown() { - this.unknownVisitor = unknownType -> { - throw new SafeIllegalArgumentException( - "Unknown variant of the 'UnionExample' union", SafeArg.of("unknownType", unknownType)); - }; - return this; - } - - @Override - public Visitor build() { - final Function, T> collectionVariantVisitor = this.collectionVariantVisitor; - final IntFunction intVariantVisitor = this.intVariantVisitor; - final Function objectVariantVisitor = this.objectVariantVisitor; - final Function, T> optionalVariantVisitor = this.optionalVariantVisitor; - final Function stringVariantVisitor = this.stringVariantVisitor; - final Function unknownVisitor = this.unknownVisitor; - return new Visitor() { - @Override - public T visitCollectionVariant(List value) { - return collectionVariantVisitor.apply(value); - } - - @Override - public T visitIntVariant(int value) { - return intVariantVisitor.apply(value); - } - - @Override - public T visitObjectVariant(ObjectReference value) { - return objectVariantVisitor.apply(value); - } - - @Override - public T visitOptionalVariant(Optional value) { - return optionalVariantVisitor.apply(value); - } - - @Override - public T visitStringVariant(String value) { - return stringVariantVisitor.apply(value); - } - - @Override - public T visitUnknown(String value) { - return unknownVisitor.apply(value); - } - }; - } - } - - public interface CollectionVariantStageVisitorBuilder { - IntVariantStageVisitorBuilder collectionVariant(@Nonnull Function, T> collectionVariantVisitor); - } - - public interface IntVariantStageVisitorBuilder { - ObjectVariantStageVisitorBuilder intVariant(@Nonnull IntFunction intVariantVisitor); - } - - public interface ObjectVariantStageVisitorBuilder { - OptionalVariantStageVisitorBuilder objectVariant(@Nonnull Function objectVariantVisitor); - } - - public interface OptionalVariantStageVisitorBuilder { - StringVariantStageVisitorBuilder optionalVariant( - @Nonnull Function, T> optionalVariantVisitor); - } - - public interface StringVariantStageVisitorBuilder { - UnknownStageVisitorBuilder stringVariant(@Nonnull Function stringVariantVisitor); - } - - public interface UnknownStageVisitorBuilder { - Completed_StageVisitorBuilder unknown(@Nonnull Function unknownVisitor); - - Completed_StageVisitorBuilder throwOnUnknown(); - } - - public interface Completed_StageVisitorBuilder { - Visitor build(); - } - - @JsonTypeInfo( - use = JsonTypeInfo.Id.NAME, - include = JsonTypeInfo.As.EXISTING_PROPERTY, - property = "type", - visible = true, - defaultImpl = UnknownWrapper.class) - @JsonSubTypes({ - @JsonSubTypes.Type(StringVariantWrapper.class), - @JsonSubTypes.Type(IntVariantWrapper.class), - @JsonSubTypes.Type(ObjectVariantWrapper.class), - @JsonSubTypes.Type(CollectionVariantWrapper.class), - @JsonSubTypes.Type(OptionalVariantWrapper.class) - }) - @JsonIgnoreProperties(ignoreUnknown = true) - private interface Base { - T accept(Visitor visitor); - } - - @JsonTypeName("stringVariant") - private static final class StringVariantWrapper implements Base { - private final String value; - - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - private StringVariantWrapper(@JsonSetter("stringVariant") @Nonnull String value) { - Preconditions.checkNotNull(value, "stringVariant cannot be null"); - this.value = value; - } - - @JsonProperty(value = "type", index = 0) - private String getType() { - return "stringVariant"; - } - - @JsonProperty("stringVariant") - private String getValue() { - return value; - } - - @Override - public T accept(Visitor visitor) { - return visitor.visitStringVariant(value); - } - - @Override - public boolean equals(@Nullable Object other) { - return this == other || (other instanceof StringVariantWrapper && equalTo((StringVariantWrapper) other)); - } - - private boolean equalTo(StringVariantWrapper other) { - return this.value.equals(other.value); - } - - @Override - public int hashCode() { - return this.value.hashCode(); - } - - @Override - public String toString() { - return "StringVariantWrapper{value: " + value + '}'; - } - } - - @JsonTypeName("intVariant") - private static final class IntVariantWrapper implements Base { - private final int value; - - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - private IntVariantWrapper(@JsonSetter("intVariant") @Nonnull int value) { - Preconditions.checkNotNull(value, "intVariant cannot be null"); - this.value = value; - } - - @JsonProperty(value = "type", index = 0) - private String getType() { - return "intVariant"; - } - - @JsonProperty("intVariant") - private int getValue() { - return value; - } - - @Override - public T accept(Visitor visitor) { - return visitor.visitIntVariant(value); - } - - @Override - public boolean equals(@Nullable Object other) { - return this == other || (other instanceof IntVariantWrapper && equalTo((IntVariantWrapper) other)); - } - - private boolean equalTo(IntVariantWrapper other) { - return this.value == other.value; - } - - @Override - public int hashCode() { - return this.value; - } - - @Override - public String toString() { - return "IntVariantWrapper{value: " + value + '}'; - } - } - - @JsonTypeName("objectVariant") - private static final class ObjectVariantWrapper implements Base { - private final ObjectReference value; - - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - private ObjectVariantWrapper(@JsonSetter("objectVariant") @Nonnull ObjectReference value) { - Preconditions.checkNotNull(value, "objectVariant cannot be null"); - this.value = value; - } - - @JsonProperty(value = "type", index = 0) - private String getType() { - return "objectVariant"; - } - - @JsonProperty("objectVariant") - private ObjectReference getValue() { - return value; - } - - @Override - public T accept(Visitor visitor) { - return visitor.visitObjectVariant(value); - } - - @Override - public boolean equals(@Nullable Object other) { - return this == other || (other instanceof ObjectVariantWrapper && equalTo((ObjectVariantWrapper) other)); - } - - private boolean equalTo(ObjectVariantWrapper other) { - return this.value.equals(other.value); - } - - @Override - public int hashCode() { - return this.value.hashCode(); - } - - @Override - public String toString() { - return "ObjectVariantWrapper{value: " + value + '}'; - } - } - - @JsonTypeName("collectionVariant") - private static final class CollectionVariantWrapper implements Base { - private final List value; - - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - private CollectionVariantWrapper( - @JsonSetter(value = "collectionVariant", nulls = Nulls.AS_EMPTY) @Nonnull List value) { - Preconditions.checkNotNull(value, "collectionVariant cannot be null"); - this.value = value; - } - - @JsonProperty(value = "type", index = 0) - private String getType() { - return "collectionVariant"; - } - - @JsonProperty("collectionVariant") - private List getValue() { - return value; - } - - @Override - public T accept(Visitor visitor) { - return visitor.visitCollectionVariant(value); - } - - @Override - public boolean equals(@Nullable Object other) { - return this == other - || (other instanceof CollectionVariantWrapper && equalTo((CollectionVariantWrapper) other)); - } - - private boolean equalTo(CollectionVariantWrapper other) { - return this.value.equals(other.value); - } - - @Override - public int hashCode() { - return this.value.hashCode(); - } - - @Override - public String toString() { - return "CollectionVariantWrapper{value: " + value + '}'; - } - } - - @JsonTypeName("optionalVariant") - private static final class OptionalVariantWrapper implements Base { - private final Optional value; - - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - private OptionalVariantWrapper( - @JsonSetter(value = "optionalVariant", nulls = Nulls.AS_EMPTY) @Nonnull Optional value) { - Preconditions.checkNotNull(value, "optionalVariant cannot be null"); - this.value = value; - } - - @JsonProperty(value = "type", index = 0) - private String getType() { - return "optionalVariant"; - } - - @JsonProperty("optionalVariant") - private Optional getValue() { - return value; - } - - @Override - public T accept(Visitor visitor) { - return visitor.visitOptionalVariant(value); - } - - @Override - public boolean equals(@Nullable Object other) { - return this == other - || (other instanceof OptionalVariantWrapper && equalTo((OptionalVariantWrapper) other)); - } - - private boolean equalTo(OptionalVariantWrapper other) { - return this.value.equals(other.value); - } - - @Override - public int hashCode() { - return this.value.hashCode(); - } - - @Override - public String toString() { - return "OptionalVariantWrapper{value: " + value + '}'; - } - } - - private static final class UnknownWrapper implements Base { - private final String type; - - private final Map value; - - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - private UnknownWrapper(@JsonProperty("type") String type) { - this(type, new HashMap()); - } - - private UnknownWrapper(@Nonnull String type, @Nonnull Map value) { - Preconditions.checkNotNull(type, "type cannot be null"); - Preconditions.checkNotNull(value, "value cannot be null"); - this.type = type; - this.value = value; - } - - @JsonProperty - private String getType() { - return type; - } - - @JsonAnyGetter - private Map getValue() { - return value; - } - - @JsonAnySetter - private void put(String key, Object val) { - value.put(key, val); - } - - @Override - public T accept(Visitor visitor) { - return visitor.visitUnknown(type); - } - - @Override - public boolean equals(@Nullable Object other) { - return this == other || (other instanceof UnknownWrapper && equalTo((UnknownWrapper) other)); - } - - private boolean equalTo(UnknownWrapper other) { - return this.type.equals(other.type) && this.value.equals(other.value); - } - - @Override - public int hashCode() { - int hash = 1; - hash = 31 * hash + this.type.hashCode(); - hash = 31 * hash + this.value.hashCode(); - return hash; - } - - @Override - public String toString() { - return "UnknownWrapper{type: " + type + ", value: " + value + '}'; - } - } -} diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/another/ConjureErrors.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/another/ConjureErrors.java deleted file mode 100644 index ea26d2a5e..000000000 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/another/ConjureErrors.java +++ /dev/null @@ -1,93 +0,0 @@ -package undertow.com.palantir.another; - -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.palantir.conjure.java.api.errors.AbstractSerializableError; -import com.palantir.conjure.java.api.errors.ErrorType; -import com.palantir.conjure.java.api.errors.RemoteException; -import com.palantir.conjure.java.api.errors.SerializableError; -import com.palantir.conjure.java.api.errors.ServiceException; -import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.Safe; -import java.util.Map; -import javax.annotation.Nullable; -import javax.annotation.processing.Generated; -import org.jetbrains.annotations.Contract; - -@Generated("com.palantir.conjure.java.types.ErrorGenerator") -public final class ConjureErrors { - /** Different package. */ - public static final ErrorType DIFFERENT_PACKAGE_ERR = - ErrorType.create(ErrorType.Code.INTERNAL, "Conjure:DifferentPackageErr"); - - private ConjureErrors() {} - - public static ServiceException differentPackageErr() { - return new ServiceException(DIFFERENT_PACKAGE_ERR); - } - - public static ServiceException differentPackageErr(@Nullable Throwable cause) { - return new ServiceException(DIFFERENT_PACKAGE_ERR, cause); - } - - /** - * Throws a {@link ServiceException} of type DifferentPackageErr when {@code shouldThrow} is true. - * - * @param shouldThrow Cause the method to throw when true - */ - @Contract("true -> fail") - public static void throwIfDifferentPackageErr(boolean shouldThrow) { - if (shouldThrow) { - throw differentPackageErr(); - } - } - - /** Returns true if the {@link RemoteException} is named Conjure:DifferentPackageErr */ - public static boolean isDifferentPackageErr(RemoteException remoteException) { - Preconditions.checkNotNull(remoteException, "remote exception must not be null"); - return DIFFERENT_PACKAGE_ERR.name().equals(remoteException.getError().errorName()); - } - - public static record DifferentPackageErrParameters() {} - - public static final class DifferentPackageErrSerializableError - extends AbstractSerializableError { - @org.jspecify.annotations.Nullable - private final Map legacyParameters; - - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - DifferentPackageErrSerializableError( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorName") @Safe String errorName, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") DifferentPackageErrParameters parameters, - @JsonProperty("legacyParameters") @org.jspecify.annotations.Nullable - Map legacyParameters) { - super(errorCode, errorName, errorInstanceId, parameters); - this.legacyParameters = legacyParameters; - } - - public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder(); - if (legacyParameters != null) { - builder.putAllParameters(legacyParameters); - } else { - } - builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); - return builder.build(); - } - } - - public static final class DifferentPackageErrException extends RemoteException { - private DifferentPackageErrSerializableError error; - - public DifferentPackageErrException(DifferentPackageErrSerializableError error, int status) { - super(error.toSerializableError(), status); - this.error = error; - } - - public DifferentPackageErrSerializableError error() { - return error; - } - } -} diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/AnyExample.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/AnyExample.java deleted file mode 100644 index f852b517e..000000000 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/AnyExample.java +++ /dev/null @@ -1,162 +0,0 @@ -package undertow.com.palantir.product; - -import com.fasterxml.jackson.annotation.JsonIgnoreProperties; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.fasterxml.jackson.annotation.JsonSetter; -import com.fasterxml.jackson.annotation.Nulls; -import com.fasterxml.jackson.databind.annotation.JsonDeserialize; -import com.google.errorprone.annotations.CheckReturnValue; -import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.SafeArg; -import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; -import java.util.ArrayList; -import java.util.Collections; -import java.util.LinkedHashMap; -import java.util.List; -import java.util.Map; -import javax.annotation.Nonnull; -import javax.annotation.Nullable; -import javax.annotation.processing.Generated; - -@JsonDeserialize(builder = AnyExample.Builder.class) -@Generated("com.palantir.conjure.java.types.BeanGenerator") -public final class AnyExample { - private final Object anyValue; - - private final Map anyMap; - - private int memoizedHashCode; - - private AnyExample(Object anyValue, Map anyMap) { - validateFields(anyValue, anyMap); - this.anyValue = anyValue; - this.anyMap = Collections.unmodifiableMap(anyMap); - } - - @JsonProperty("anyValue") - public Object getAnyValue() { - return this.anyValue; - } - - @JsonProperty("anyMap") - public Map getAnyMap() { - return this.anyMap; - } - - @Override - public boolean equals(@Nullable Object other) { - return this == other || (other instanceof AnyExample && equalTo((AnyExample) other)); - } - - private boolean equalTo(AnyExample other) { - if (this.memoizedHashCode != 0 - && other.memoizedHashCode != 0 - && this.memoizedHashCode != other.memoizedHashCode) { - return false; - } - return this.anyValue.equals(other.anyValue) && this.anyMap.equals(other.anyMap); - } - - @Override - public int hashCode() { - int result = memoizedHashCode; - if (result == 0) { - int hash = 1; - hash = 31 * hash + this.anyValue.hashCode(); - hash = 31 * hash + this.anyMap.hashCode(); - result = hash; - memoizedHashCode = result; - } - return result; - } - - @Override - public String toString() { - return "AnyExample{anyValue: " + anyValue + ", anyMap: " + anyMap + '}'; - } - - public static AnyExample of(Object anyValue, Map anyMap) { - return builder().anyValue(anyValue).anyMap(anyMap).build(); - } - - private static void validateFields(Object anyValue, Map anyMap) { - List missingFields = null; - missingFields = addFieldIfMissing(missingFields, anyValue, "anyValue"); - missingFields = addFieldIfMissing(missingFields, anyMap, "anyMap"); - if (missingFields != null) { - throw new SafeIllegalArgumentException( - "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); - } - } - - private static List addFieldIfMissing(List prev, Object fieldValue, String fieldName) { - List missingFields = prev; - if (fieldValue == null) { - if (missingFields == null) { - missingFields = new ArrayList<>(2); - } - missingFields.add(fieldName); - } - return missingFields; - } - - public static Builder builder() { - return new Builder(); - } - - @Generated("com.palantir.conjure.java.types.BeanBuilderGenerator") - @JsonIgnoreProperties(ignoreUnknown = true) - public static final class Builder { - boolean _buildInvoked; - - private Object anyValue; - - private Map anyMap = new LinkedHashMap<>(); - - private Builder() {} - - public Builder from(AnyExample other) { - checkNotBuilt(); - anyValue(other.getAnyValue()); - anyMap(other.getAnyMap()); - return this; - } - - @JsonSetter("anyValue") - public Builder anyValue(@Nonnull Object anyValue) { - checkNotBuilt(); - this.anyValue = Preconditions.checkNotNull(anyValue, "anyValue cannot be null"); - return this; - } - - @JsonSetter(value = "anyMap", nulls = Nulls.SKIP, contentNulls = Nulls.FAIL) - public Builder anyMap(@Nonnull Map anyMap) { - checkNotBuilt(); - this.anyMap = new LinkedHashMap<>(Preconditions.checkNotNull(anyMap, "anyMap cannot be null")); - return this; - } - - public Builder putAllAnyMap(@Nonnull Map anyMap) { - checkNotBuilt(); - this.anyMap.putAll(Preconditions.checkNotNull(anyMap, "anyMap cannot be null")); - return this; - } - - public Builder anyMap(String key, Object value) { - checkNotBuilt(); - this.anyMap.put(key, value); - return this; - } - - @CheckReturnValue - public AnyExample build() { - checkNotBuilt(); - this._buildInvoked = true; - return new AnyExample(anyValue, anyMap); - } - - private void checkNotBuilt() { - Preconditions.checkState(!_buildInvoked, "Build has already been called"); - } - } -} diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/CollectionAlias.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/CollectionAlias.java deleted file mode 100644 index 0771470b2..000000000 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/CollectionAlias.java +++ /dev/null @@ -1,70 +0,0 @@ -package undertow.com.palantir.product; - -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonValue; -import com.palantir.logsafe.Preconditions; -import java.util.Collections; -import java.util.List; -import javax.annotation.Nonnull; -import javax.annotation.Nullable; -import javax.annotation.processing.Generated; - -@Generated("com.palantir.conjure.java.types.AliasGenerator") -public final class CollectionAlias { - private static final CollectionAlias EMPTY = new CollectionAlias(); - - private final List value; - - private int memoizedHashCode; - - private CollectionAlias(@Nonnull List value) { - this.value = Preconditions.checkNotNull(value, "value cannot be null"); - } - - private CollectionAlias() { - this(Collections.emptyList()); - } - - @JsonValue - public List get() { - return value; - } - - @Override - public String toString() { - return value.toString(); - } - - @Override - public boolean equals(@Nullable Object other) { - return this == other || (other instanceof CollectionAlias && equalTo((CollectionAlias) other)); - } - - private boolean equalTo(CollectionAlias other) { - if (this.memoizedHashCode != 0 - && other.memoizedHashCode != 0 - && this.memoizedHashCode != other.memoizedHashCode) { - return false; - } - return this.value.equals(other.value); - } - - @Override - public int hashCode() { - int result = memoizedHashCode; - if (result == 0) { - result = this.value.hashCode(); - memoizedHashCode = result; - } - return result; - } - - @JsonCreator(mode = JsonCreator.Mode.DELEGATING) - public static CollectionAlias of(@Nonnull List value) { - return new CollectionAlias(value); - } - - public static CollectionAlias empty() { - return EMPTY; - } -} diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/CollectionExample.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/CollectionExample.java deleted file mode 100644 index 43387ed33..000000000 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/CollectionExample.java +++ /dev/null @@ -1,221 +0,0 @@ -package undertow.com.palantir.product; - -import com.fasterxml.jackson.annotation.JsonIgnoreProperties; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.fasterxml.jackson.annotation.JsonSetter; -import com.fasterxml.jackson.annotation.Nulls; -import com.fasterxml.jackson.databind.annotation.JsonDeserialize; -import com.google.errorprone.annotations.CheckReturnValue; -import com.palantir.conjure.java.lib.internal.ConjureCollections; -import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.SafeArg; -import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; -import java.util.ArrayList; -import java.util.Collections; -import java.util.LinkedHashMap; -import java.util.List; -import java.util.Map; -import java.util.Set; -import javax.annotation.Nonnull; -import javax.annotation.Nullable; -import javax.annotation.processing.Generated; - -@JsonDeserialize(builder = CollectionExample.Builder.class) -@Generated("com.palantir.conjure.java.types.BeanGenerator") -public final class CollectionExample { - private final List stringList; - - private final Set stringSet; - - private final Map stringMap; - - private int memoizedHashCode; - - private CollectionExample(List stringList, Set stringSet, Map stringMap) { - validateFields(stringList, stringSet, stringMap); - this.stringList = ConjureCollections.unmodifiableList(stringList); - this.stringSet = Collections.unmodifiableSet(stringSet); - this.stringMap = Collections.unmodifiableMap(stringMap); - } - - @JsonProperty("stringList") - public List getStringList() { - return this.stringList; - } - - @JsonProperty("stringSet") - public Set getStringSet() { - return this.stringSet; - } - - @JsonProperty("stringMap") - public Map getStringMap() { - return this.stringMap; - } - - @Override - public boolean equals(@Nullable Object other) { - return this == other || (other instanceof CollectionExample && equalTo((CollectionExample) other)); - } - - private boolean equalTo(CollectionExample other) { - if (this.memoizedHashCode != 0 - && other.memoizedHashCode != 0 - && this.memoizedHashCode != other.memoizedHashCode) { - return false; - } - return this.stringList.equals(other.stringList) - && this.stringSet.equals(other.stringSet) - && this.stringMap.equals(other.stringMap); - } - - @Override - public int hashCode() { - int result = memoizedHashCode; - if (result == 0) { - int hash = 1; - hash = 31 * hash + this.stringList.hashCode(); - hash = 31 * hash + this.stringSet.hashCode(); - hash = 31 * hash + this.stringMap.hashCode(); - result = hash; - memoizedHashCode = result; - } - return result; - } - - @Override - public String toString() { - return "CollectionExample{stringList: " + stringList + ", stringSet: " + stringSet + ", stringMap: " + stringMap - + '}'; - } - - public static CollectionExample of(List stringList, Set stringSet, Map stringMap) { - return builder() - .stringList(stringList) - .stringSet(stringSet) - .stringMap(stringMap) - .build(); - } - - private static void validateFields(List stringList, Set stringSet, Map stringMap) { - List missingFields = null; - missingFields = addFieldIfMissing(missingFields, stringList, "stringList"); - missingFields = addFieldIfMissing(missingFields, stringSet, "stringSet"); - missingFields = addFieldIfMissing(missingFields, stringMap, "stringMap"); - if (missingFields != null) { - throw new SafeIllegalArgumentException( - "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); - } - } - - private static List addFieldIfMissing(List prev, Object fieldValue, String fieldName) { - List missingFields = prev; - if (fieldValue == null) { - if (missingFields == null) { - missingFields = new ArrayList<>(3); - } - missingFields.add(fieldName); - } - return missingFields; - } - - public static Builder builder() { - return new Builder(); - } - - @Generated("com.palantir.conjure.java.types.BeanBuilderGenerator") - @JsonIgnoreProperties(ignoreUnknown = true) - public static final class Builder { - boolean _buildInvoked; - - private List stringList = ConjureCollections.newNonNullList(); - - private Set stringSet = ConjureCollections.newNonNullSet(); - - private Map stringMap = new LinkedHashMap<>(); - - private Builder() {} - - public Builder from(CollectionExample other) { - checkNotBuilt(); - stringList(other.getStringList()); - stringSet(other.getStringSet()); - stringMap(other.getStringMap()); - return this; - } - - @JsonSetter(value = "stringList", nulls = Nulls.SKIP, contentNulls = Nulls.FAIL) - public Builder stringList(@Nonnull Iterable stringList) { - checkNotBuilt(); - this.stringList = ConjureCollections.newNonNullList( - Preconditions.checkNotNull(stringList, "stringList cannot be null")); - return this; - } - - public Builder addAllStringList(@Nonnull Iterable stringList) { - checkNotBuilt(); - ConjureCollections.addAllAndCheckNonNull( - this.stringList, Preconditions.checkNotNull(stringList, "stringList cannot be null")); - return this; - } - - public Builder stringList(String stringList) { - checkNotBuilt(); - Preconditions.checkNotNull(stringList, "stringList cannot be null"); - this.stringList.add(stringList); - return this; - } - - @JsonSetter(value = "stringSet", nulls = Nulls.SKIP, contentNulls = Nulls.FAIL) - public Builder stringSet(@Nonnull Iterable stringSet) { - checkNotBuilt(); - this.stringSet = - ConjureCollections.newNonNullSet(Preconditions.checkNotNull(stringSet, "stringSet cannot be null")); - return this; - } - - public Builder addAllStringSet(@Nonnull Iterable stringSet) { - checkNotBuilt(); - ConjureCollections.addAllAndCheckNonNull( - this.stringSet, Preconditions.checkNotNull(stringSet, "stringSet cannot be null")); - return this; - } - - public Builder stringSet(String stringSet) { - checkNotBuilt(); - Preconditions.checkNotNull(stringSet, "stringSet cannot be null"); - this.stringSet.add(stringSet); - return this; - } - - @JsonSetter(value = "stringMap", nulls = Nulls.SKIP, contentNulls = Nulls.FAIL) - public Builder stringMap(@Nonnull Map stringMap) { - checkNotBuilt(); - this.stringMap = new LinkedHashMap<>(Preconditions.checkNotNull(stringMap, "stringMap cannot be null")); - return this; - } - - public Builder putAllStringMap(@Nonnull Map stringMap) { - checkNotBuilt(); - this.stringMap.putAll(Preconditions.checkNotNull(stringMap, "stringMap cannot be null")); - return this; - } - - public Builder stringMap(String key, String value) { - checkNotBuilt(); - this.stringMap.put(key, value); - return this; - } - - @CheckReturnValue - public CollectionExample build() { - checkNotBuilt(); - this._buildInvoked = true; - return new CollectionExample(stringList, stringSet, stringMap); - } - - private void checkNotBuilt() { - Preconditions.checkState(!_buildInvoked, "Build has already been called"); - } - } -} diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ComplexExample.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ComplexExample.java deleted file mode 100644 index 9c9e15fdb..000000000 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ComplexExample.java +++ /dev/null @@ -1,237 +0,0 @@ -package undertow.com.palantir.product; - -import com.fasterxml.jackson.annotation.JsonIgnoreProperties; -import com.fasterxml.jackson.annotation.JsonInclude; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.fasterxml.jackson.annotation.JsonSetter; -import com.fasterxml.jackson.annotation.Nulls; -import com.fasterxml.jackson.databind.annotation.JsonDeserialize; -import com.google.errorprone.annotations.CheckReturnValue; -import com.palantir.conjure.java.lib.internal.ConjureCollections; -import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.SafeArg; -import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; -import java.util.ArrayList; -import java.util.Collections; -import java.util.LinkedHashMap; -import java.util.List; -import java.util.Map; -import java.util.Optional; -import java.util.function.Function; -import javax.annotation.Nonnull; -import javax.annotation.Nullable; -import javax.annotation.processing.Generated; - -@JsonDeserialize(builder = ComplexExample.Builder.class) -@Generated("com.palantir.conjure.java.types.BeanGenerator") -public final class ComplexExample { - private final Map>> metadata; - - private final EnumExample status; - - private final List variants; - - private final Optional external; - - private int memoizedHashCode; - - private ComplexExample( - Map>> metadata, - EnumExample status, - List variants, - Optional external) { - validateFields(metadata, status, variants, external); - this.metadata = Collections.unmodifiableMap(metadata); - this.status = status; - this.variants = ConjureCollections.unmodifiableList(variants); - this.external = external; - } - - @JsonProperty("metadata") - public Map>> getMetadata() { - return this.metadata; - } - - @JsonProperty("status") - public EnumExample getStatus() { - return this.status; - } - - @JsonProperty("variants") - public List getVariants() { - return this.variants; - } - - @JsonProperty("external") - @JsonInclude(JsonInclude.Include.NON_ABSENT) - public Optional getExternal() { - return this.external; - } - - @Override - public boolean equals(@Nullable Object other) { - return this == other || (other instanceof ComplexExample && equalTo((ComplexExample) other)); - } - - private boolean equalTo(ComplexExample other) { - if (this.memoizedHashCode != 0 - && other.memoizedHashCode != 0 - && this.memoizedHashCode != other.memoizedHashCode) { - return false; - } - return this.metadata.equals(other.metadata) - && this.status.equals(other.status) - && this.variants.equals(other.variants) - && this.external.equals(other.external); - } - - @Override - public int hashCode() { - int result = memoizedHashCode; - if (result == 0) { - int hash = 1; - hash = 31 * hash + this.metadata.hashCode(); - hash = 31 * hash + this.status.hashCode(); - hash = 31 * hash + this.variants.hashCode(); - hash = 31 * hash + this.external.hashCode(); - result = hash; - memoizedHashCode = result; - } - return result; - } - - @Override - public String toString() { - return "ComplexExample{metadata: " + metadata + ", status: " + status + ", variants: " + variants - + ", external: " + external + '}'; - } - - private static void validateFields( - Map>> metadata, - EnumExample status, - List variants, - Optional external) { - List missingFields = null; - missingFields = addFieldIfMissing(missingFields, metadata, "metadata"); - missingFields = addFieldIfMissing(missingFields, status, "status"); - missingFields = addFieldIfMissing(missingFields, variants, "variants"); - missingFields = addFieldIfMissing(missingFields, external, "external"); - if (missingFields != null) { - throw new SafeIllegalArgumentException( - "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); - } - } - - private static List addFieldIfMissing(List prev, Object fieldValue, String fieldName) { - List missingFields = prev; - if (fieldValue == null) { - if (missingFields == null) { - missingFields = new ArrayList<>(4); - } - missingFields.add(fieldName); - } - return missingFields; - } - - public static Builder builder() { - return new Builder(); - } - - @Generated("com.palantir.conjure.java.types.BeanBuilderGenerator") - @JsonIgnoreProperties(ignoreUnknown = true) - public static final class Builder { - boolean _buildInvoked; - - private Map>> metadata = new LinkedHashMap<>(); - - private EnumExample status; - - private List variants = ConjureCollections.newNonNullList(); - - private Optional external = Optional.empty(); - - private Builder() {} - - public Builder from(ComplexExample other) { - checkNotBuilt(); - metadata(other.getMetadata()); - status(other.getStatus()); - variants(other.getVariants()); - external(other.getExternal()); - return this; - } - - @JsonSetter(value = "metadata", nulls = Nulls.SKIP, contentNulls = Nulls.AS_EMPTY) - public Builder metadata(@Nonnull Map>> metadata) { - checkNotBuilt(); - this.metadata = new LinkedHashMap<>(Preconditions.checkNotNull(metadata, "metadata cannot be null")); - return this; - } - - public Builder putAllMetadata(@Nonnull Map>> metadata) { - checkNotBuilt(); - this.metadata.putAll(Preconditions.checkNotNull(metadata, "metadata cannot be null")); - return this; - } - - public Builder metadata(StringAliasEx key, Optional> value) { - checkNotBuilt(); - this.metadata.put(key, value); - return this; - } - - @JsonSetter("status") - public Builder status(@Nonnull EnumExample status) { - checkNotBuilt(); - this.status = Preconditions.checkNotNull(status, "status cannot be null"); - return this; - } - - @JsonSetter(value = "variants", nulls = Nulls.SKIP, contentNulls = Nulls.FAIL) - public Builder variants(@Nonnull Iterable variants) { - checkNotBuilt(); - this.variants = - ConjureCollections.newNonNullList(Preconditions.checkNotNull(variants, "variants cannot be null")); - return this; - } - - public Builder addAllVariants(@Nonnull Iterable variants) { - checkNotBuilt(); - ConjureCollections.addAllAndCheckNonNull( - this.variants, Preconditions.checkNotNull(variants, "variants cannot be null")); - return this; - } - - public Builder variants(UnionExample variants) { - checkNotBuilt(); - Preconditions.checkNotNull(variants, "variants cannot be null"); - this.variants.add(variants); - return this; - } - - @JsonSetter(value = "external", nulls = Nulls.SKIP) - public Builder external(@Nonnull Optional external) { - checkNotBuilt(); - this.external = Preconditions.checkNotNull(external, "external cannot be null") - .map(Function.identity()); - return this; - } - - public Builder external(long external) { - checkNotBuilt(); - this.external = Optional.of(Preconditions.checkNotNull(external, "external cannot be null")); - return this; - } - - @CheckReturnValue - public ComplexExample build() { - checkNotBuilt(); - this._buildInvoked = true; - return new ComplexExample(metadata, status, variants, external); - } - - private void checkNotBuilt() { - Preconditions.checkState(!_buildInvoked, "Build has already been called"); - } - } -} diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ConjureErrors.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ConjureErrors.java index ca5650870..250f0e745 100644 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ConjureErrors.java +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ConjureErrors.java @@ -6,313 +6,21 @@ import com.palantir.conjure.java.api.errors.ErrorType; import com.palantir.conjure.java.api.errors.RemoteException; import com.palantir.conjure.java.api.errors.SerializableError; -import com.palantir.conjure.java.api.errors.ServiceException; import com.palantir.logsafe.Preconditions; import com.palantir.logsafe.Safe; -import com.palantir.logsafe.SafeArg; -import com.palantir.logsafe.Unsafe; -import com.palantir.logsafe.UnsafeArg; import java.util.Map; import java.util.Objects; -import javax.annotation.Nullable; import javax.annotation.processing.Generated; -import org.jetbrains.annotations.Contract; +import org.jspecify.annotations.Nullable; @Generated("com.palantir.conjure.java.types.ErrorGenerator") public final class ConjureErrors { - /** Cause argument conflicts with reserved Throwable cause parameter. */ - public static final ErrorType CONFLICTING_CAUSE_SAFE_ARG = - ErrorType.create(ErrorType.Code.INTERNAL, "Conjure:ConflictingCauseSafeArg"); - /** Cause argument conflicts with reserved Throwable cause parameter. */ public static final ErrorType CONFLICTING_CAUSE_SAFE_ARG_ERR = ErrorType.create(ErrorType.Code.INTERNAL, "Conjure:ConflictingCauseSafeArgErr"); - /** Cause argument conflicts with reserved Throwable cause parameter. */ - public static final ErrorType CONFLICTING_CAUSE_UNSAFE_ARG = - ErrorType.create(ErrorType.Code.INTERNAL, "Conjure:ConflictingCauseUnsafeArg"); - - public static final ErrorType ERROR_WITH_COMPLEX_ARGS = - ErrorType.create(ErrorType.Code.INTERNAL, "Conjure:ErrorWithComplexArgs"); - - /** Invalid Conjure service definition. */ - public static final ErrorType INVALID_SERVICE_DEFINITION = - ErrorType.create(ErrorType.Code.INVALID_ARGUMENT, "Conjure:InvalidServiceDefinition"); - - /** Invalid Conjure type definition. */ - public static final ErrorType INVALID_TYPE_DEFINITION = - ErrorType.create(ErrorType.Code.INVALID_ARGUMENT, "Conjure:InvalidTypeDefinition"); - private ConjureErrors() {} - public static ServiceException conflictingCauseSafeArg(@Safe String cause_, @Safe boolean shouldThrow_) { - return new ServiceException( - CONFLICTING_CAUSE_SAFE_ARG, SafeArg.of("cause", cause_), SafeArg.of("shouldThrow", shouldThrow_)); - } - - public static ServiceException conflictingCauseSafeArg( - @Nullable Throwable cause, @Safe String cause_, @Safe boolean shouldThrow_) { - return new ServiceException( - CONFLICTING_CAUSE_SAFE_ARG, - cause, - SafeArg.of("cause", cause_), - SafeArg.of("shouldThrow", shouldThrow_)); - } - - public static ServiceException conflictingCauseUnsafeArg(@Unsafe String cause_, @Unsafe boolean shouldThrow_) { - return new ServiceException( - CONFLICTING_CAUSE_UNSAFE_ARG, UnsafeArg.of("cause", cause_), UnsafeArg.of("shouldThrow", shouldThrow_)); - } - - public static ServiceException conflictingCauseUnsafeArg( - @Nullable Throwable cause, @Unsafe String cause_, @Unsafe boolean shouldThrow_) { - return new ServiceException( - CONFLICTING_CAUSE_UNSAFE_ARG, - cause, - UnsafeArg.of("cause", cause_), - UnsafeArg.of("shouldThrow", shouldThrow_)); - } - - public static ServiceException errorWithComplexArgs( - @Safe PrimitiveExample primitiveExample, - @Safe CollectionExample collectionExample, - @Safe NestedCollectionExample nestedCollectionExample, - @Safe OptionalExample optionalExample, - @Safe ObjectReference objectReference, - @Safe UnionExample unionExample, - @Safe EnumExample enumExample, - @Safe StringAliasEx stringAlias, - @Safe OptionalAlias optionalAlias, - @Safe CollectionAlias collectionAlias, - @Safe NestedAlias nestedAlias, - @Safe ExternalExample externalExample, - @Safe AnyExample anyExample, - @Safe EmptyObject emptyObject, - @Safe ComplexExample complexExample, - @Unsafe SafetyExample safetyExample) { - return new ServiceException( - ERROR_WITH_COMPLEX_ARGS, - SafeArg.of("primitiveExample", primitiveExample), - SafeArg.of("collectionExample", collectionExample), - SafeArg.of("nestedCollectionExample", nestedCollectionExample), - SafeArg.of("optionalExample", optionalExample), - SafeArg.of("objectReference", objectReference), - SafeArg.of("unionExample", unionExample), - SafeArg.of("enumExample", enumExample), - SafeArg.of("stringAlias", stringAlias), - SafeArg.of("optionalAlias", optionalAlias), - SafeArg.of("collectionAlias", collectionAlias), - SafeArg.of("nestedAlias", nestedAlias), - SafeArg.of("externalExample", externalExample), - SafeArg.of("anyExample", anyExample), - SafeArg.of("emptyObject", emptyObject), - SafeArg.of("complexExample", complexExample), - UnsafeArg.of("safetyExample", safetyExample)); - } - - public static ServiceException errorWithComplexArgs( - @Nullable Throwable cause, - @Safe PrimitiveExample primitiveExample, - @Safe CollectionExample collectionExample, - @Safe NestedCollectionExample nestedCollectionExample, - @Safe OptionalExample optionalExample, - @Safe ObjectReference objectReference, - @Safe UnionExample unionExample, - @Safe EnumExample enumExample, - @Safe StringAliasEx stringAlias, - @Safe OptionalAlias optionalAlias, - @Safe CollectionAlias collectionAlias, - @Safe NestedAlias nestedAlias, - @Safe ExternalExample externalExample, - @Safe AnyExample anyExample, - @Safe EmptyObject emptyObject, - @Safe ComplexExample complexExample, - @Unsafe SafetyExample safetyExample) { - return new ServiceException( - ERROR_WITH_COMPLEX_ARGS, - cause, - SafeArg.of("primitiveExample", primitiveExample), - SafeArg.of("collectionExample", collectionExample), - SafeArg.of("nestedCollectionExample", nestedCollectionExample), - SafeArg.of("optionalExample", optionalExample), - SafeArg.of("objectReference", objectReference), - SafeArg.of("unionExample", unionExample), - SafeArg.of("enumExample", enumExample), - SafeArg.of("stringAlias", stringAlias), - SafeArg.of("optionalAlias", optionalAlias), - SafeArg.of("collectionAlias", collectionAlias), - SafeArg.of("nestedAlias", nestedAlias), - SafeArg.of("externalExample", externalExample), - SafeArg.of("anyExample", anyExample), - SafeArg.of("emptyObject", emptyObject), - SafeArg.of("complexExample", complexExample), - UnsafeArg.of("safetyExample", safetyExample)); - } - - /** - * @param serviceName Name of the invalid service definition. - * @param serviceDef Details of the invalid service definition. - */ - public static ServiceException invalidServiceDefinition(@Safe String serviceName, @Unsafe Object serviceDef) { - return new ServiceException( - INVALID_SERVICE_DEFINITION, - SafeArg.of("serviceName", serviceName), - UnsafeArg.of("serviceDef", serviceDef)); - } - - /** - * @param serviceName Name of the invalid service definition. - * @param serviceDef Details of the invalid service definition. - */ - public static ServiceException invalidServiceDefinition( - @Nullable Throwable cause, @Safe String serviceName, @Unsafe Object serviceDef) { - return new ServiceException( - INVALID_SERVICE_DEFINITION, - cause, - SafeArg.of("serviceName", serviceName), - UnsafeArg.of("serviceDef", serviceDef)); - } - - public static ServiceException invalidTypeDefinition(@Safe String typeName, @Unsafe Object typeDef) { - return new ServiceException( - INVALID_TYPE_DEFINITION, SafeArg.of("typeName", typeName), UnsafeArg.of("typeDef", typeDef)); - } - - public static ServiceException invalidTypeDefinition( - @Nullable Throwable cause, @Safe String typeName, @Unsafe Object typeDef) { - return new ServiceException( - INVALID_TYPE_DEFINITION, cause, SafeArg.of("typeName", typeName), UnsafeArg.of("typeDef", typeDef)); - } - - /** - * Throws a {@link ServiceException} of type ConflictingCauseSafeArg when {@code shouldThrow} is true. - * - * @param shouldThrow Cause the method to throw when true - * @param cause_ - * @param shouldThrow_ - */ - @Contract("true, _, _ -> fail") - public static void throwIfConflictingCauseSafeArg( - boolean shouldThrow, @Safe String cause_, @Safe boolean shouldThrow_) { - if (shouldThrow) { - throw conflictingCauseSafeArg(cause_, shouldThrow_); - } - } - - /** - * Throws a {@link ServiceException} of type ConflictingCauseUnsafeArg when {@code shouldThrow} is true. - * - * @param shouldThrow Cause the method to throw when true - * @param cause_ - * @param shouldThrow_ - */ - @Contract("true, _, _ -> fail") - public static void throwIfConflictingCauseUnsafeArg( - boolean shouldThrow, @Unsafe String cause_, @Unsafe boolean shouldThrow_) { - if (shouldThrow) { - throw conflictingCauseUnsafeArg(cause_, shouldThrow_); - } - } - - /** - * Throws a {@link ServiceException} of type ErrorWithComplexArgs when {@code shouldThrow} is true. - * - * @param shouldThrow Cause the method to throw when true - * @param primitiveExample - * @param collectionExample - * @param nestedCollectionExample - * @param optionalExample - * @param objectReference - * @param unionExample - * @param enumExample - * @param stringAlias - * @param optionalAlias - * @param collectionAlias - * @param nestedAlias - * @param externalExample - * @param anyExample - * @param emptyObject - * @param complexExample - * @param safetyExample - */ - @Contract("true, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ -> fail") - public static void throwIfErrorWithComplexArgs( - boolean shouldThrow, - @Safe PrimitiveExample primitiveExample, - @Safe CollectionExample collectionExample, - @Safe NestedCollectionExample nestedCollectionExample, - @Safe OptionalExample optionalExample, - @Safe ObjectReference objectReference, - @Safe UnionExample unionExample, - @Safe EnumExample enumExample, - @Safe StringAliasEx stringAlias, - @Safe OptionalAlias optionalAlias, - @Safe CollectionAlias collectionAlias, - @Safe NestedAlias nestedAlias, - @Safe ExternalExample externalExample, - @Safe AnyExample anyExample, - @Safe EmptyObject emptyObject, - @Safe ComplexExample complexExample, - @Unsafe SafetyExample safetyExample) { - if (shouldThrow) { - throw errorWithComplexArgs( - primitiveExample, - collectionExample, - nestedCollectionExample, - optionalExample, - objectReference, - unionExample, - enumExample, - stringAlias, - optionalAlias, - collectionAlias, - nestedAlias, - externalExample, - anyExample, - emptyObject, - complexExample, - safetyExample); - } - } - - /** - * Throws a {@link ServiceException} of type InvalidServiceDefinition when {@code shouldThrow} is true. - * - * @param shouldThrow Cause the method to throw when true - * @param serviceName Name of the invalid service definition. - * @param serviceDef Details of the invalid service definition. - */ - @Contract("true, _, _ -> fail") - public static void throwIfInvalidServiceDefinition( - boolean shouldThrow, @Safe String serviceName, @Unsafe Object serviceDef) { - if (shouldThrow) { - throw invalidServiceDefinition(serviceName, serviceDef); - } - } - - /** - * Throws a {@link ServiceException} of type InvalidTypeDefinition when {@code shouldThrow} is true. - * - * @param shouldThrow Cause the method to throw when true - * @param typeName - * @param typeDef - */ - @Contract("true, _, _ -> fail") - public static void throwIfInvalidTypeDefinition( - boolean shouldThrow, @Safe String typeName, @Unsafe Object typeDef) { - if (shouldThrow) { - throw invalidTypeDefinition(typeName, typeDef); - } - } - - /** Returns true if the {@link RemoteException} is named Conjure:ConflictingCauseSafeArg */ - public static boolean isConflictingCauseSafeArg(RemoteException remoteException) { - Preconditions.checkNotNull(remoteException, "remote exception must not be null"); - return CONFLICTING_CAUSE_SAFE_ARG - .name() - .equals(remoteException.getError().errorName()); - } - /** Returns true if the {@link RemoteException} is named Conjure:ConflictingCauseSafeArgErr */ public static boolean isConflictingCauseSafeArgErr(RemoteException remoteException) { Preconditions.checkNotNull(remoteException, "remote exception must not be null"); @@ -321,106 +29,12 @@ public static boolean isConflictingCauseSafeArgErr(RemoteException remoteExcepti .equals(remoteException.getError().errorName()); } - /** Returns true if the {@link RemoteException} is named Conjure:ConflictingCauseUnsafeArg */ - public static boolean isConflictingCauseUnsafeArg(RemoteException remoteException) { - Preconditions.checkNotNull(remoteException, "remote exception must not be null"); - return CONFLICTING_CAUSE_UNSAFE_ARG - .name() - .equals(remoteException.getError().errorName()); - } - - /** Returns true if the {@link RemoteException} is named Conjure:ErrorWithComplexArgs */ - public static boolean isErrorWithComplexArgs(RemoteException remoteException) { - Preconditions.checkNotNull(remoteException, "remote exception must not be null"); - return ERROR_WITH_COMPLEX_ARGS.name().equals(remoteException.getError().errorName()); - } - - /** Returns true if the {@link RemoteException} is named Conjure:InvalidServiceDefinition */ - public static boolean isInvalidServiceDefinition(RemoteException remoteException) { - Preconditions.checkNotNull(remoteException, "remote exception must not be null"); - return INVALID_SERVICE_DEFINITION - .name() - .equals(remoteException.getError().errorName()); - } - - /** Returns true if the {@link RemoteException} is named Conjure:InvalidTypeDefinition */ - public static boolean isInvalidTypeDefinition(RemoteException remoteException) { - Preconditions.checkNotNull(remoteException, "remote exception must not be null"); - return INVALID_TYPE_DEFINITION.name().equals(remoteException.getError().errorName()); - } - - public static record ConflictingCauseSafeArgParameters( - @JsonProperty("cause") @Safe String cause_, @JsonProperty("shouldThrow") @Safe boolean shouldThrow_) {} - public static record ConflictingCauseSafeArgErrParameters( @JsonProperty("cause") @Safe String cause_, @JsonProperty("shouldThrow") @Safe boolean shouldThrow_) {} - public static record ConflictingCauseUnsafeArgParameters( - @JsonProperty("cause") @Unsafe String cause_, @JsonProperty("shouldThrow") @Unsafe boolean shouldThrow_) {} - - public static record ErrorWithComplexArgsParameters( - @JsonProperty("primitiveExample") @Safe PrimitiveExample primitiveExample, - @JsonProperty("collectionExample") @Safe CollectionExample collectionExample, - @JsonProperty("nestedCollectionExample") @Safe NestedCollectionExample nestedCollectionExample, - @JsonProperty("optionalExample") @Safe OptionalExample optionalExample, - @JsonProperty("objectReference") @Safe ObjectReference objectReference, - @JsonProperty("unionExample") @Safe UnionExample unionExample, - @JsonProperty("enumExample") @Safe EnumExample enumExample, - @JsonProperty("stringAlias") @Safe StringAliasEx stringAlias, - @JsonProperty("optionalAlias") @Safe OptionalAlias optionalAlias, - @JsonProperty("collectionAlias") @Safe CollectionAlias collectionAlias, - @JsonProperty("nestedAlias") @Safe NestedAlias nestedAlias, - @JsonProperty("externalExample") @Safe ExternalExample externalExample, - @JsonProperty("anyExample") @Safe AnyExample anyExample, - @JsonProperty("emptyObject") @Safe EmptyObject emptyObject, - @JsonProperty("complexExample") @Safe ComplexExample complexExample, - @JsonProperty("safetyExample") @Unsafe SafetyExample safetyExample) {} - - /** - * @param serviceName Name of the invalid service definition. - * @param serviceDef Details of the invalid service definition. - */ - public static record InvalidServiceDefinitionParameters( - @JsonProperty("serviceName") @Safe String serviceName, - @JsonProperty("serviceDef") @Unsafe Object serviceDef) {} - - public static record InvalidTypeDefinitionParameters( - @JsonProperty("typeName") @Safe String typeName, @JsonProperty("typeDef") @Unsafe Object typeDef) {} - - public static final class ConflictingCauseSafeArgSerializableError - extends AbstractSerializableError { - @org.jspecify.annotations.Nullable - private final Map legacyParameters; - - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - ConflictingCauseSafeArgSerializableError( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorName") @Safe String errorName, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") ConflictingCauseSafeArgParameters parameters, - @JsonProperty("legacyParameters") @org.jspecify.annotations.Nullable - Map legacyParameters) { - super(errorCode, errorName, errorInstanceId, parameters); - this.legacyParameters = legacyParameters; - } - - public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder(); - if (legacyParameters != null) { - builder.putAllParameters(legacyParameters); - } else { - builder.putParameters("cause", Objects.toString(parameters().cause_())) - .putParameters( - "shouldThrow", Objects.toString(parameters().shouldThrow_())); - } - builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); - return builder.build(); - } - } - public static final class ConflictingCauseSafeArgErrSerializableError extends AbstractSerializableError { - @org.jspecify.annotations.Nullable + @Nullable private final Map legacyParameters; @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) @@ -429,39 +43,7 @@ public static final class ConflictingCauseSafeArgErrSerializableError @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, @JsonProperty("parameters") ConflictingCauseSafeArgErrParameters parameters, - @JsonProperty("legacyParameters") @org.jspecify.annotations.Nullable - Map legacyParameters) { - super(errorCode, errorName, errorInstanceId, parameters); - this.legacyParameters = legacyParameters; - } - - public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder(); - if (legacyParameters != null) { - builder.putAllParameters(legacyParameters); - } else { - builder.putParameters("cause", Objects.toString(parameters().cause_())) - .putParameters( - "shouldThrow", Objects.toString(parameters().shouldThrow_())); - } - builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); - return builder.build(); - } - } - - public static final class ConflictingCauseUnsafeArgSerializableError - extends AbstractSerializableError { - @org.jspecify.annotations.Nullable - private final Map legacyParameters; - - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - ConflictingCauseUnsafeArgSerializableError( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorName") @Safe String errorName, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") ConflictingCauseUnsafeArgParameters parameters, - @JsonProperty("legacyParameters") @org.jspecify.annotations.Nullable - Map legacyParameters) { + @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { super(errorCode, errorName, errorInstanceId, parameters); this.legacyParameters = legacyParameters; } @@ -480,144 +62,6 @@ public SerializableError toSerializableError() { } } - public static final class ErrorWithComplexArgsSerializableError - extends AbstractSerializableError { - @org.jspecify.annotations.Nullable - private final Map legacyParameters; - - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - ErrorWithComplexArgsSerializableError( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorName") @Safe String errorName, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") ErrorWithComplexArgsParameters parameters, - @JsonProperty("legacyParameters") @org.jspecify.annotations.Nullable - Map legacyParameters) { - super(errorCode, errorName, errorInstanceId, parameters); - this.legacyParameters = legacyParameters; - } - - public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder(); - if (legacyParameters != null) { - builder.putAllParameters(legacyParameters); - } else { - builder.putParameters( - "primitiveExample", - Objects.toString(parameters().primitiveExample())) - .putParameters( - "collectionExample", - Objects.toString(parameters().collectionExample())) - .putParameters( - "nestedCollectionExample", - Objects.toString(parameters().nestedCollectionExample())) - .putParameters( - "optionalExample", Objects.toString(parameters().optionalExample())) - .putParameters( - "objectReference", Objects.toString(parameters().objectReference())) - .putParameters( - "unionExample", Objects.toString(parameters().unionExample())) - .putParameters( - "enumExample", Objects.toString(parameters().enumExample())) - .putParameters( - "stringAlias", Objects.toString(parameters().stringAlias())) - .putParameters( - "optionalAlias", Objects.toString(parameters().optionalAlias())) - .putParameters( - "collectionAlias", Objects.toString(parameters().collectionAlias())) - .putParameters( - "nestedAlias", Objects.toString(parameters().nestedAlias())) - .putParameters( - "externalExample", Objects.toString(parameters().externalExample())) - .putParameters( - "anyExample", Objects.toString(parameters().anyExample())) - .putParameters( - "emptyObject", Objects.toString(parameters().emptyObject())) - .putParameters( - "complexExample", Objects.toString(parameters().complexExample())) - .putParameters( - "safetyExample", Objects.toString(parameters().safetyExample())); - } - builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); - return builder.build(); - } - } - - public static final class InvalidServiceDefinitionSerializableError - extends AbstractSerializableError { - @org.jspecify.annotations.Nullable - private final Map legacyParameters; - - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - InvalidServiceDefinitionSerializableError( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorName") @Safe String errorName, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") InvalidServiceDefinitionParameters parameters, - @JsonProperty("legacyParameters") @org.jspecify.annotations.Nullable - Map legacyParameters) { - super(errorCode, errorName, errorInstanceId, parameters); - this.legacyParameters = legacyParameters; - } - - public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder(); - if (legacyParameters != null) { - builder.putAllParameters(legacyParameters); - } else { - builder.putParameters( - "serviceName", Objects.toString(parameters().serviceName())) - .putParameters( - "serviceDef", Objects.toString(parameters().serviceDef())); - } - builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); - return builder.build(); - } - } - - public static final class InvalidTypeDefinitionSerializableError - extends AbstractSerializableError { - @org.jspecify.annotations.Nullable - private final Map legacyParameters; - - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - InvalidTypeDefinitionSerializableError( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorName") @Safe String errorName, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") InvalidTypeDefinitionParameters parameters, - @JsonProperty("legacyParameters") @org.jspecify.annotations.Nullable - Map legacyParameters) { - super(errorCode, errorName, errorInstanceId, parameters); - this.legacyParameters = legacyParameters; - } - - public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder(); - if (legacyParameters != null) { - builder.putAllParameters(legacyParameters); - } else { - builder.putParameters("typeName", Objects.toString(parameters().typeName())) - .putParameters("typeDef", Objects.toString(parameters().typeDef())); - } - builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); - return builder.build(); - } - } - - public static final class ConflictingCauseSafeArgException extends RemoteException { - private ConflictingCauseSafeArgSerializableError error; - - public ConflictingCauseSafeArgException(ConflictingCauseSafeArgSerializableError error, int status) { - super(error.toSerializableError(), status); - this.error = error; - } - - public ConflictingCauseSafeArgSerializableError error() { - return error; - } - } - public static final class ConflictingCauseSafeArgErrException extends RemoteException { private ConflictingCauseSafeArgErrSerializableError error; @@ -630,56 +74,4 @@ public ConflictingCauseSafeArgErrSerializableError error() { return error; } } - - public static final class ConflictingCauseUnsafeArgException extends RemoteException { - private ConflictingCauseUnsafeArgSerializableError error; - - public ConflictingCauseUnsafeArgException(ConflictingCauseUnsafeArgSerializableError error, int status) { - super(error.toSerializableError(), status); - this.error = error; - } - - public ConflictingCauseUnsafeArgSerializableError error() { - return error; - } - } - - public static final class ErrorWithComplexArgsException extends RemoteException { - private ErrorWithComplexArgsSerializableError error; - - public ErrorWithComplexArgsException(ErrorWithComplexArgsSerializableError error, int status) { - super(error.toSerializableError(), status); - this.error = error; - } - - public ErrorWithComplexArgsSerializableError error() { - return error; - } - } - - public static final class InvalidServiceDefinitionException extends RemoteException { - private InvalidServiceDefinitionSerializableError error; - - public InvalidServiceDefinitionException(InvalidServiceDefinitionSerializableError error, int status) { - super(error.toSerializableError(), status); - this.error = error; - } - - public InvalidServiceDefinitionSerializableError error() { - return error; - } - } - - public static final class InvalidTypeDefinitionException extends RemoteException { - private InvalidTypeDefinitionSerializableError error; - - public InvalidTypeDefinitionException(InvalidTypeDefinitionSerializableError error, int status) { - super(error.toSerializableError(), status); - this.error = error; - } - - public InvalidTypeDefinitionSerializableError error() { - return error; - } - } } diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ConjureJavaErrors.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ConjureJavaErrors.java deleted file mode 100644 index cb8949661..000000000 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ConjureJavaErrors.java +++ /dev/null @@ -1,93 +0,0 @@ -package undertow.com.palantir.product; - -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.palantir.conjure.java.api.errors.AbstractSerializableError; -import com.palantir.conjure.java.api.errors.ErrorType; -import com.palantir.conjure.java.api.errors.RemoteException; -import com.palantir.conjure.java.api.errors.SerializableError; -import com.palantir.conjure.java.api.errors.ServiceException; -import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.Safe; -import java.util.Map; -import javax.annotation.Nullable; -import javax.annotation.processing.Generated; -import org.jetbrains.annotations.Contract; - -@Generated("com.palantir.conjure.java.types.ErrorGenerator") -public final class ConjureJavaErrors { - /** Failed to compile Conjure definition to Java code. */ - public static final ErrorType JAVA_COMPILATION_FAILED = - ErrorType.create(ErrorType.Code.INTERNAL, "ConjureJava:JavaCompilationFailed"); - - private ConjureJavaErrors() {} - - public static ServiceException javaCompilationFailed() { - return new ServiceException(JAVA_COMPILATION_FAILED); - } - - public static ServiceException javaCompilationFailed(@Nullable Throwable cause) { - return new ServiceException(JAVA_COMPILATION_FAILED, cause); - } - - /** - * Throws a {@link ServiceException} of type JavaCompilationFailed when {@code shouldThrow} is true. - * - * @param shouldThrow Cause the method to throw when true - */ - @Contract("true -> fail") - public static void throwIfJavaCompilationFailed(boolean shouldThrow) { - if (shouldThrow) { - throw javaCompilationFailed(); - } - } - - /** Returns true if the {@link RemoteException} is named ConjureJava:JavaCompilationFailed */ - public static boolean isJavaCompilationFailed(RemoteException remoteException) { - Preconditions.checkNotNull(remoteException, "remote exception must not be null"); - return JAVA_COMPILATION_FAILED.name().equals(remoteException.getError().errorName()); - } - - public static record JavaCompilationFailedParameters() {} - - public static final class JavaCompilationFailedSerializableError - extends AbstractSerializableError { - @org.jspecify.annotations.Nullable - private final Map legacyParameters; - - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - JavaCompilationFailedSerializableError( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorName") @Safe String errorName, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") JavaCompilationFailedParameters parameters, - @JsonProperty("legacyParameters") @org.jspecify.annotations.Nullable - Map legacyParameters) { - super(errorCode, errorName, errorInstanceId, parameters); - this.legacyParameters = legacyParameters; - } - - public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder(); - if (legacyParameters != null) { - builder.putAllParameters(legacyParameters); - } else { - } - builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); - return builder.build(); - } - } - - public static final class JavaCompilationFailedException extends RemoteException { - private JavaCompilationFailedSerializableError error; - - public JavaCompilationFailedException(JavaCompilationFailedSerializableError error, int status) { - super(error.toSerializableError(), status); - this.error = error; - } - - public JavaCompilationFailedSerializableError error() { - return error; - } - } -} diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EmptyObject.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EmptyObject.java deleted file mode 100644 index c2ba580b8..000000000 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EmptyObject.java +++ /dev/null @@ -1,28 +0,0 @@ -package undertow.com.palantir.product; - -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonIgnoreProperties; -import com.fasterxml.jackson.databind.annotation.JsonSerialize; -import com.palantir.logsafe.Safe; -import javax.annotation.processing.Generated; - -@Safe -@JsonSerialize -@JsonIgnoreProperties(ignoreUnknown = true) -@Generated("com.palantir.conjure.java.types.BeanGenerator") -public final class EmptyObject { - private static final EmptyObject INSTANCE = new EmptyObject(); - - private EmptyObject() {} - - @Override - @Safe - public String toString() { - return "EmptyObject{}"; - } - - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - public static EmptyObject of() { - return INSTANCE; - } -} diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EmptyUnion.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EmptyUnion.java deleted file mode 100644 index 1f24db371..000000000 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EmptyUnion.java +++ /dev/null @@ -1,186 +0,0 @@ -package undertow.com.palantir.product; - -import com.fasterxml.jackson.annotation.JsonAnyGetter; -import com.fasterxml.jackson.annotation.JsonAnySetter; -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonIgnoreProperties; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.fasterxml.jackson.annotation.JsonTypeInfo; -import com.fasterxml.jackson.annotation.JsonValue; -import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.Safe; -import com.palantir.logsafe.SafeArg; -import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; -import java.util.Collections; -import java.util.HashMap; -import java.util.Map; -import java.util.function.Function; -import javax.annotation.Nonnull; -import javax.annotation.Nullable; -import javax.annotation.processing.Generated; - -@Generated("com.palantir.conjure.java.types.UnionGenerator") -public final class EmptyUnion { - private final Base value; - - @JsonCreator(mode = JsonCreator.Mode.DELEGATING) - private EmptyUnion(Base value) { - this.value = value; - } - - @JsonValue - private Base getValue() { - return value; - } - - public static EmptyUnion unknown(@Safe String type, Object value) { - switch (Preconditions.checkNotNull(type, "Type is required")) { - default: - return new EmptyUnion(new UnknownWrapper(type, Collections.singletonMap(type, value))); - } - } - - public T accept(Visitor visitor) { - return value.accept(visitor); - } - - @Override - public boolean equals(@Nullable Object other) { - return this == other || (other instanceof EmptyUnion && equalTo((EmptyUnion) other)); - } - - private boolean equalTo(EmptyUnion other) { - return this.value.equals(other.value); - } - - @Override - public int hashCode() { - return this.value.hashCode(); - } - - @Override - public String toString() { - return "EmptyUnion{value: " + value + '}'; - } - - public interface Visitor { - T visitUnknown(@Safe String unknownType); - - static UnknownStageVisitorBuilder builder() { - return new VisitorBuilder(); - } - } - - private static final class VisitorBuilder - implements UnknownStageVisitorBuilder, Completed_StageVisitorBuilder { - private Function unknownVisitor; - - @Override - public Completed_StageVisitorBuilder unknown(@Nonnull Function unknownVisitor) { - Preconditions.checkNotNull(unknownVisitor, "unknownVisitor cannot be null"); - this.unknownVisitor = unknownVisitor; - return this; - } - - @Override - public Completed_StageVisitorBuilder throwOnUnknown() { - this.unknownVisitor = unknownType -> { - throw new SafeIllegalArgumentException( - "Unknown variant of the 'EmptyUnion' union", SafeArg.of("unknownType", unknownType)); - }; - return this; - } - - @Override - public Visitor build() { - final Function unknownVisitor = this.unknownVisitor; - return new Visitor() { - @Override - public T visitUnknown(String value) { - return unknownVisitor.apply(value); - } - }; - } - } - - public interface UnknownStageVisitorBuilder { - Completed_StageVisitorBuilder unknown(@Nonnull Function unknownVisitor); - - Completed_StageVisitorBuilder throwOnUnknown(); - } - - public interface Completed_StageVisitorBuilder { - Visitor build(); - } - - @JsonTypeInfo( - use = JsonTypeInfo.Id.NAME, - include = JsonTypeInfo.As.EXISTING_PROPERTY, - property = "type", - visible = true, - defaultImpl = UnknownWrapper.class) - @JsonIgnoreProperties(ignoreUnknown = true) - private interface Base { - T accept(Visitor visitor); - } - - private static final class UnknownWrapper implements Base { - private final String type; - - private final Map value; - - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - private UnknownWrapper(@JsonProperty("type") String type) { - this(type, new HashMap()); - } - - private UnknownWrapper(@Nonnull String type, @Nonnull Map value) { - Preconditions.checkNotNull(type, "type cannot be null"); - Preconditions.checkNotNull(value, "value cannot be null"); - this.type = type; - this.value = value; - } - - @JsonProperty - private String getType() { - return type; - } - - @JsonAnyGetter - private Map getValue() { - return value; - } - - @JsonAnySetter - private void put(String key, Object val) { - value.put(key, val); - } - - @Override - public T accept(Visitor visitor) { - return visitor.visitUnknown(type); - } - - @Override - public boolean equals(@Nullable Object other) { - return this == other || (other instanceof UnknownWrapper && equalTo((UnknownWrapper) other)); - } - - private boolean equalTo(UnknownWrapper other) { - return this.type.equals(other.type) && this.value.equals(other.value); - } - - @Override - public int hashCode() { - int hash = 1; - hash = 31 * hash + this.type.hashCode(); - hash = 31 * hash + this.value.hashCode(); - return hash; - } - - @Override - public String toString() { - return "UnknownWrapper{type: " + type + ", value: " + value + '}'; - } - } -} diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EnumExample.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EnumExample.java deleted file mode 100644 index a7aed5d7f..000000000 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EnumExample.java +++ /dev/null @@ -1,205 +0,0 @@ -package undertow.com.palantir.product; - -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonValue; -import com.google.errorprone.annotations.Immutable; -import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.Safe; -import com.palantir.logsafe.SafeArg; -import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; -import java.util.Arrays; -import java.util.Collections; -import java.util.List; -import java.util.Locale; -import java.util.function.Function; -import java.util.function.Supplier; -import javax.annotation.Nonnull; -import javax.annotation.Nullable; -import javax.annotation.processing.Generated; - -/** - * This class is used instead of a native enum to support unknown values. Rather than throw an exception, the - * {@link EnumExample#valueOf} method defaults to a new instantiation of {@link EnumExample} where - * {@link EnumExample#get} will return {@link EnumExample.Value#UNKNOWN}. - * - *

For example, {@code EnumExample.valueOf("corrupted value").get()} will return {@link EnumExample.Value#UNKNOWN}, - * but {@link EnumExample#toString} will return "corrupted value". - * - *

There is no method to access all instantiations of this class, since they cannot be known at compile time. - */ -@Generated("com.palantir.conjure.java.types.EnumGenerator") -@Safe -@Immutable -public final class EnumExample { - public static final EnumExample A = new EnumExample(Value.A, "A"); - - public static final EnumExample B = new EnumExample(Value.B, "B"); - - private static final List values = Collections.unmodifiableList(Arrays.asList(A, B)); - - private final Value value; - - private final String string; - - private EnumExample(Value value, String string) { - this.value = value; - this.string = string; - } - - public Value get() { - return this.value; - } - - @Override - @JsonValue - public String toString() { - return this.string; - } - - @Override - public boolean equals(@Nullable Object other) { - return (this == other) - || (this.value == Value.UNKNOWN - && other instanceof EnumExample - && this.string.equals(((EnumExample) other).string)); - } - - @Override - public int hashCode() { - return this.string.hashCode(); - } - - @JsonCreator(mode = JsonCreator.Mode.DELEGATING) - public static EnumExample valueOf(@Nonnull @Safe String value) { - Preconditions.checkNotNull(value, "value cannot be null"); - String upperCasedValue = value.toUpperCase(Locale.ROOT); - switch (upperCasedValue) { - case "A": - return A; - case "B": - return B; - default: - return new EnumExample(Value.UNKNOWN, upperCasedValue); - } - } - - public T accept(Visitor visitor) { - switch (value) { - case A: - return visitor.visitA(); - case B: - return visitor.visitB(); - default: - return visitor.visitUnknown(string); - } - } - - public static List values() { - return values; - } - - @Generated("com.palantir.conjure.java.types.EnumGenerator") - public enum Value { - A, - - B, - - UNKNOWN - } - - @Generated("com.palantir.conjure.java.types.EnumGenerator") - public interface Visitor { - T visitA(); - - T visitB(); - - T visitUnknown(String unknownValue); - - static AStageVisitorBuilder builder() { - return new VisitorBuilder(); - } - } - - private static final class VisitorBuilder - implements AStageVisitorBuilder, - BStageVisitorBuilder, - UnknownStageVisitorBuilder, - Completed_StageVisitorBuilder { - private Supplier aVisitor; - - private Supplier bVisitor; - - private Function<@Safe String, T> unknownVisitor; - - @Override - public BStageVisitorBuilder visitA(@Nonnull Supplier aVisitor) { - Preconditions.checkNotNull(aVisitor, "aVisitor cannot be null"); - this.aVisitor = aVisitor; - return this; - } - - @Override - public UnknownStageVisitorBuilder visitB(@Nonnull Supplier bVisitor) { - Preconditions.checkNotNull(bVisitor, "bVisitor cannot be null"); - this.bVisitor = bVisitor; - return this; - } - - @Override - public Completed_StageVisitorBuilder visitUnknown(@Nonnull Function<@Safe String, T> unknownVisitor) { - Preconditions.checkNotNull(unknownVisitor, "unknownVisitor cannot be null"); - this.unknownVisitor = unknownType -> unknownVisitor.apply(unknownType); - return this; - } - - @Override - public Completed_StageVisitorBuilder throwOnUnknown() { - this.unknownVisitor = unknownType -> { - throw new SafeIllegalArgumentException( - "Unknown variant of the 'EnumExample' union", SafeArg.of("unknownType", unknownType)); - }; - return this; - } - - @Override - public Visitor build() { - final Supplier aVisitor = this.aVisitor; - final Supplier bVisitor = this.bVisitor; - final Function<@Safe String, T> unknownVisitor = this.unknownVisitor; - return new Visitor() { - @Override - public T visitA() { - return aVisitor.get(); - } - - @Override - public T visitB() { - return bVisitor.get(); - } - - @Override - public T visitUnknown(String unknownType) { - return unknownVisitor.apply(unknownType); - } - }; - } - } - - public interface AStageVisitorBuilder { - BStageVisitorBuilder visitA(@Nonnull Supplier aVisitor); - } - - public interface BStageVisitorBuilder { - UnknownStageVisitorBuilder visitB(@Nonnull Supplier bVisitor); - } - - public interface UnknownStageVisitorBuilder { - Completed_StageVisitorBuilder visitUnknown(@Nonnull Function<@Safe String, T> unknownVisitor); - - Completed_StageVisitorBuilder throwOnUnknown(); - } - - public interface Completed_StageVisitorBuilder { - Visitor build(); - } -} diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ExternalExample.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ExternalExample.java deleted file mode 100644 index fe87fe650..000000000 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ExternalExample.java +++ /dev/null @@ -1,185 +0,0 @@ -package undertow.com.palantir.product; - -import com.fasterxml.jackson.annotation.JsonIgnoreProperties; -import com.fasterxml.jackson.annotation.JsonInclude; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.fasterxml.jackson.annotation.JsonSetter; -import com.fasterxml.jackson.annotation.Nulls; -import com.fasterxml.jackson.databind.annotation.JsonDeserialize; -import com.google.errorprone.annotations.CheckReturnValue; -import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.SafeArg; -import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; -import java.util.ArrayList; -import java.util.List; -import java.util.Optional; -import java.util.function.Function; -import javax.annotation.Nonnull; -import javax.annotation.Nullable; -import javax.annotation.processing.Generated; - -@JsonDeserialize(builder = ExternalExample.Builder.class) -@Generated("com.palantir.conjure.java.types.BeanGenerator") -public final class ExternalExample { - private final long externalLong; - - private final Optional optionalExternal; - - private int memoizedHashCode; - - private ExternalExample(long externalLong, Optional optionalExternal) { - validateFields(optionalExternal); - this.externalLong = externalLong; - this.optionalExternal = optionalExternal; - } - - @JsonProperty("externalLong") - public long getExternalLong() { - return this.externalLong; - } - - @JsonProperty("optionalExternal") - @JsonInclude(JsonInclude.Include.NON_ABSENT) - public Optional getOptionalExternal() { - return this.optionalExternal; - } - - @Override - public boolean equals(@Nullable Object other) { - return this == other || (other instanceof ExternalExample && equalTo((ExternalExample) other)); - } - - private boolean equalTo(ExternalExample other) { - if (this.memoizedHashCode != 0 - && other.memoizedHashCode != 0 - && this.memoizedHashCode != other.memoizedHashCode) { - return false; - } - return this.externalLong == other.externalLong && this.optionalExternal.equals(other.optionalExternal); - } - - @Override - public int hashCode() { - int result = memoizedHashCode; - if (result == 0) { - int hash = 1; - hash = 31 * hash + Long.hashCode(this.externalLong); - hash = 31 * hash + this.optionalExternal.hashCode(); - result = hash; - memoizedHashCode = result; - } - return result; - } - - @Override - public String toString() { - return "ExternalExample{externalLong: " + externalLong + ", optionalExternal: " + optionalExternal + '}'; - } - - public static ExternalExample of(long externalLong, long optionalExternal) { - return builder() - .externalLong(externalLong) - .optionalExternal(Optional.of(optionalExternal)) - .build(); - } - - private static void validateFields(Optional optionalExternal) { - List missingFields = null; - missingFields = addFieldIfMissing(missingFields, optionalExternal, "optionalExternal"); - if (missingFields != null) { - throw new SafeIllegalArgumentException( - "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); - } - } - - private static List addFieldIfMissing(List prev, Object fieldValue, String fieldName) { - List missingFields = prev; - if (fieldValue == null) { - if (missingFields == null) { - missingFields = new ArrayList<>(1); - } - missingFields.add(fieldName); - } - return missingFields; - } - - public static Builder builder() { - return new Builder(); - } - - @Generated("com.palantir.conjure.java.types.BeanBuilderGenerator") - @JsonIgnoreProperties(ignoreUnknown = true) - public static final class Builder { - boolean _buildInvoked; - - private long externalLong; - - private Optional optionalExternal = Optional.empty(); - - private boolean _externalLongInitialized = false; - - private Builder() {} - - public Builder from(ExternalExample other) { - checkNotBuilt(); - externalLong(other.getExternalLong()); - optionalExternal(other.getOptionalExternal()); - return this; - } - - @JsonSetter("externalLong") - public Builder externalLong(long externalLong) { - checkNotBuilt(); - this.externalLong = externalLong; - this._externalLongInitialized = true; - return this; - } - - @JsonSetter(value = "optionalExternal", nulls = Nulls.SKIP) - public Builder optionalExternal(@Nonnull Optional optionalExternal) { - checkNotBuilt(); - this.optionalExternal = Preconditions.checkNotNull(optionalExternal, "optionalExternal cannot be null") - .map(Function.identity()); - return this; - } - - public Builder optionalExternal(long optionalExternal) { - checkNotBuilt(); - this.optionalExternal = - Optional.of(Preconditions.checkNotNull(optionalExternal, "optionalExternal cannot be null")); - return this; - } - - private void validatePrimitiveFieldsHaveBeenInitialized() { - List missingFields = null; - missingFields = addFieldIfMissing(missingFields, _externalLongInitialized, "externalLong"); - if (missingFields != null) { - throw new SafeIllegalArgumentException( - "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); - } - } - - private static List addFieldIfMissing(List prev, boolean initialized, String fieldName) { - List missingFields = prev; - if (!initialized) { - if (missingFields == null) { - missingFields = new ArrayList<>(1); - } - missingFields.add(fieldName); - } - return missingFields; - } - - @CheckReturnValue - public ExternalExample build() { - checkNotBuilt(); - this._buildInvoked = true; - validatePrimitiveFieldsHaveBeenInitialized(); - return new ExternalExample(externalLong, optionalExternal); - } - - private void checkNotBuilt() { - Preconditions.checkState(!_buildInvoked, "Build has already been called"); - } - } -} diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/NestedAlias.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/NestedAlias.java deleted file mode 100644 index c5ab4bb44..000000000 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/NestedAlias.java +++ /dev/null @@ -1,52 +0,0 @@ -package undertow.com.palantir.product; - -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonValue; -import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.Safe; -import javax.annotation.Nonnull; -import javax.annotation.Nullable; -import javax.annotation.processing.Generated; - -@Safe -@Generated("com.palantir.conjure.java.types.AliasGenerator") -public final class NestedAlias { - private final StringAliasEx value; - - private NestedAlias(@Nonnull StringAliasEx value) { - this.value = Preconditions.checkNotNull(value, "value cannot be null"); - } - - @JsonValue - public StringAliasEx get() { - return value; - } - - @Override - public String toString() { - return value.toString(); - } - - @Override - public boolean equals(@Nullable Object other) { - return this == other || (other instanceof NestedAlias && equalTo((NestedAlias) other)); - } - - private boolean equalTo(NestedAlias other) { - return this.value.equals(other.value); - } - - @Override - public int hashCode() { - return this.value.hashCode(); - } - - public static NestedAlias valueOf(@Safe String value) { - return of(StringAliasEx.valueOf(value)); - } - - @JsonCreator(mode = JsonCreator.Mode.DELEGATING) - public static NestedAlias of(@Nonnull StringAliasEx value) { - return new NestedAlias(value); - } -} diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/NestedCollectionExample.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/NestedCollectionExample.java deleted file mode 100644 index 09e3c6ea3..000000000 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/NestedCollectionExample.java +++ /dev/null @@ -1,227 +0,0 @@ -package undertow.com.palantir.product; - -import com.fasterxml.jackson.annotation.JsonIgnoreProperties; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.fasterxml.jackson.annotation.JsonSetter; -import com.fasterxml.jackson.annotation.Nulls; -import com.fasterxml.jackson.databind.annotation.JsonDeserialize; -import com.google.errorprone.annotations.CheckReturnValue; -import com.palantir.conjure.java.lib.internal.ConjureCollections; -import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.SafeArg; -import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; -import java.util.ArrayList; -import java.util.Collections; -import java.util.LinkedHashMap; -import java.util.List; -import java.util.Map; -import javax.annotation.Nonnull; -import javax.annotation.Nullable; -import javax.annotation.processing.Generated; - -@JsonDeserialize(builder = NestedCollectionExample.Builder.class) -@Generated("com.palantir.conjure.java.types.BeanGenerator") -public final class NestedCollectionExample { - private final List> nestedList; - - private final Map> nestedMap; - - private final Map> mixedCollection; - - private int memoizedHashCode; - - private NestedCollectionExample( - List> nestedList, - Map> nestedMap, - Map> mixedCollection) { - validateFields(nestedList, nestedMap, mixedCollection); - this.nestedList = ConjureCollections.unmodifiableList(nestedList); - this.nestedMap = Collections.unmodifiableMap(nestedMap); - this.mixedCollection = Collections.unmodifiableMap(mixedCollection); - } - - @JsonProperty("nestedList") - public List> getNestedList() { - return this.nestedList; - } - - @JsonProperty("nestedMap") - public Map> getNestedMap() { - return this.nestedMap; - } - - @JsonProperty("mixedCollection") - public Map> getMixedCollection() { - return this.mixedCollection; - } - - @Override - public boolean equals(@Nullable Object other) { - return this == other || (other instanceof NestedCollectionExample && equalTo((NestedCollectionExample) other)); - } - - private boolean equalTo(NestedCollectionExample other) { - if (this.memoizedHashCode != 0 - && other.memoizedHashCode != 0 - && this.memoizedHashCode != other.memoizedHashCode) { - return false; - } - return this.nestedList.equals(other.nestedList) - && this.nestedMap.equals(other.nestedMap) - && this.mixedCollection.equals(other.mixedCollection); - } - - @Override - public int hashCode() { - int result = memoizedHashCode; - if (result == 0) { - int hash = 1; - hash = 31 * hash + this.nestedList.hashCode(); - hash = 31 * hash + this.nestedMap.hashCode(); - hash = 31 * hash + this.mixedCollection.hashCode(); - result = hash; - memoizedHashCode = result; - } - return result; - } - - @Override - public String toString() { - return "NestedCollectionExample{nestedList: " + nestedList + ", nestedMap: " + nestedMap + ", mixedCollection: " - + mixedCollection + '}'; - } - - public static NestedCollectionExample of( - List> nestedList, - Map> nestedMap, - Map> mixedCollection) { - return builder() - .nestedList(nestedList) - .nestedMap(nestedMap) - .mixedCollection(mixedCollection) - .build(); - } - - private static void validateFields( - List> nestedList, - Map> nestedMap, - Map> mixedCollection) { - List missingFields = null; - missingFields = addFieldIfMissing(missingFields, nestedList, "nestedList"); - missingFields = addFieldIfMissing(missingFields, nestedMap, "nestedMap"); - missingFields = addFieldIfMissing(missingFields, mixedCollection, "mixedCollection"); - if (missingFields != null) { - throw new SafeIllegalArgumentException( - "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); - } - } - - private static List addFieldIfMissing(List prev, Object fieldValue, String fieldName) { - List missingFields = prev; - if (fieldValue == null) { - if (missingFields == null) { - missingFields = new ArrayList<>(3); - } - missingFields.add(fieldName); - } - return missingFields; - } - - public static Builder builder() { - return new Builder(); - } - - @Generated("com.palantir.conjure.java.types.BeanBuilderGenerator") - @JsonIgnoreProperties(ignoreUnknown = true) - public static final class Builder { - boolean _buildInvoked; - - private List> nestedList = ConjureCollections.newNonNullList(); - - private Map> nestedMap = new LinkedHashMap<>(); - - private Map> mixedCollection = new LinkedHashMap<>(); - - private Builder() {} - - public Builder from(NestedCollectionExample other) { - checkNotBuilt(); - nestedList(other.getNestedList()); - nestedMap(other.getNestedMap()); - mixedCollection(other.getMixedCollection()); - return this; - } - - @JsonSetter(value = "nestedList", nulls = Nulls.SKIP, contentNulls = Nulls.FAIL) - public Builder nestedList(@Nonnull Iterable> nestedList) { - checkNotBuilt(); - this.nestedList = ConjureCollections.newNonNullList( - Preconditions.checkNotNull(nestedList, "nestedList cannot be null")); - return this; - } - - public Builder addAllNestedList(@Nonnull Iterable> nestedList) { - checkNotBuilt(); - ConjureCollections.addAllAndCheckNonNull( - this.nestedList, Preconditions.checkNotNull(nestedList, "nestedList cannot be null")); - return this; - } - - public Builder nestedList(List nestedList) { - checkNotBuilt(); - Preconditions.checkNotNull(nestedList, "nestedList cannot be null"); - this.nestedList.add(nestedList); - return this; - } - - @JsonSetter(value = "nestedMap", nulls = Nulls.SKIP, contentNulls = Nulls.FAIL) - public Builder nestedMap(@Nonnull Map> nestedMap) { - checkNotBuilt(); - this.nestedMap = new LinkedHashMap<>(Preconditions.checkNotNull(nestedMap, "nestedMap cannot be null")); - return this; - } - - public Builder putAllNestedMap(@Nonnull Map> nestedMap) { - checkNotBuilt(); - this.nestedMap.putAll(Preconditions.checkNotNull(nestedMap, "nestedMap cannot be null")); - return this; - } - - public Builder nestedMap(String key, Map value) { - checkNotBuilt(); - this.nestedMap.put(key, value); - return this; - } - - @JsonSetter(value = "mixedCollection", nulls = Nulls.SKIP, contentNulls = Nulls.FAIL) - public Builder mixedCollection(@Nonnull Map> mixedCollection) { - checkNotBuilt(); - this.mixedCollection = - new LinkedHashMap<>(Preconditions.checkNotNull(mixedCollection, "mixedCollection cannot be null")); - return this; - } - - public Builder putAllMixedCollection(@Nonnull Map> mixedCollection) { - checkNotBuilt(); - this.mixedCollection.putAll(Preconditions.checkNotNull(mixedCollection, "mixedCollection cannot be null")); - return this; - } - - public Builder mixedCollection(String key, List value) { - checkNotBuilt(); - this.mixedCollection.put(key, value); - return this; - } - - @CheckReturnValue - public NestedCollectionExample build() { - checkNotBuilt(); - this._buildInvoked = true; - return new NestedCollectionExample(nestedList, nestedMap, mixedCollection); - } - - private void checkNotBuilt() { - Preconditions.checkState(!_buildInvoked, "Build has already been called"); - } - } -} diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ObjectReference.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ObjectReference.java deleted file mode 100644 index 833a1d2fc..000000000 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ObjectReference.java +++ /dev/null @@ -1,169 +0,0 @@ -package undertow.com.palantir.product; - -import com.fasterxml.jackson.annotation.JsonIgnoreProperties; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.fasterxml.jackson.annotation.JsonSetter; -import com.fasterxml.jackson.databind.annotation.JsonDeserialize; -import com.google.errorprone.annotations.CheckReturnValue; -import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.SafeArg; -import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; -import java.util.ArrayList; -import java.util.List; -import javax.annotation.Nonnull; -import javax.annotation.Nullable; -import javax.annotation.processing.Generated; - -@JsonDeserialize(builder = ObjectReference.Builder.class) -@Generated("com.palantir.conjure.java.types.BeanGenerator") -public final class ObjectReference { - private final String name; - - private final int value; - - private int memoizedHashCode; - - private ObjectReference(String name, int value) { - validateFields(name); - this.name = name; - this.value = value; - } - - @JsonProperty("name") - public String getName() { - return this.name; - } - - @JsonProperty("value") - public int getValue() { - return this.value; - } - - @Override - public boolean equals(@Nullable Object other) { - return this == other || (other instanceof ObjectReference && equalTo((ObjectReference) other)); - } - - private boolean equalTo(ObjectReference other) { - if (this.memoizedHashCode != 0 - && other.memoizedHashCode != 0 - && this.memoizedHashCode != other.memoizedHashCode) { - return false; - } - return this.name.equals(other.name) && this.value == other.value; - } - - @Override - public int hashCode() { - int result = memoizedHashCode; - if (result == 0) { - int hash = 1; - hash = 31 * hash + this.name.hashCode(); - hash = 31 * hash + this.value; - result = hash; - memoizedHashCode = result; - } - return result; - } - - @Override - public String toString() { - return "ObjectReference{name: " + name + ", value: " + value + '}'; - } - - public static ObjectReference of(String name, int value) { - return builder().name(name).value(value).build(); - } - - private static void validateFields(String name) { - List missingFields = null; - missingFields = addFieldIfMissing(missingFields, name, "name"); - if (missingFields != null) { - throw new SafeIllegalArgumentException( - "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); - } - } - - private static List addFieldIfMissing(List prev, Object fieldValue, String fieldName) { - List missingFields = prev; - if (fieldValue == null) { - if (missingFields == null) { - missingFields = new ArrayList<>(1); - } - missingFields.add(fieldName); - } - return missingFields; - } - - public static Builder builder() { - return new Builder(); - } - - @Generated("com.palantir.conjure.java.types.BeanBuilderGenerator") - @JsonIgnoreProperties(ignoreUnknown = true) - public static final class Builder { - boolean _buildInvoked; - - private String name; - - private int value; - - private boolean _valueInitialized = false; - - private Builder() {} - - public Builder from(ObjectReference other) { - checkNotBuilt(); - name(other.getName()); - value(other.getValue()); - return this; - } - - @JsonSetter("name") - public Builder name(@Nonnull String name) { - checkNotBuilt(); - this.name = Preconditions.checkNotNull(name, "name cannot be null"); - return this; - } - - @JsonSetter("value") - public Builder value(int value) { - checkNotBuilt(); - this.value = value; - this._valueInitialized = true; - return this; - } - - private void validatePrimitiveFieldsHaveBeenInitialized() { - List missingFields = null; - missingFields = addFieldIfMissing(missingFields, _valueInitialized, "value"); - if (missingFields != null) { - throw new SafeIllegalArgumentException( - "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); - } - } - - private static List addFieldIfMissing(List prev, boolean initialized, String fieldName) { - List missingFields = prev; - if (!initialized) { - if (missingFields == null) { - missingFields = new ArrayList<>(1); - } - missingFields.add(fieldName); - } - return missingFields; - } - - @CheckReturnValue - public ObjectReference build() { - checkNotBuilt(); - this._buildInvoked = true; - validatePrimitiveFieldsHaveBeenInitialized(); - return new ObjectReference(name, value); - } - - private void checkNotBuilt() { - Preconditions.checkState(!_buildInvoked, "Build has already been called"); - } - } -} diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/OptionalAlias.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/OptionalAlias.java deleted file mode 100644 index 50a669fe1..000000000 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/OptionalAlias.java +++ /dev/null @@ -1,60 +0,0 @@ -package undertow.com.palantir.product; - -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonValue; -import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.Safe; -import java.util.Optional; -import javax.annotation.Nonnull; -import javax.annotation.Nullable; -import javax.annotation.processing.Generated; - -@Safe -@Generated("com.palantir.conjure.java.types.AliasGenerator") -public final class OptionalAlias { - private static final OptionalAlias EMPTY = new OptionalAlias(); - - private final Optional<@Safe String> value; - - private OptionalAlias(@Nonnull Optional<@Safe String> value) { - this.value = Preconditions.checkNotNull(value, "value cannot be null"); - } - - private OptionalAlias() { - this(Optional.empty()); - } - - @JsonValue - public Optional<@Safe String> get() { - return value; - } - - @Override - @Safe - public String toString() { - return value.toString(); - } - - @Override - public boolean equals(@Nullable Object other) { - return this == other || (other instanceof OptionalAlias && equalTo((OptionalAlias) other)); - } - - private boolean equalTo(OptionalAlias other) { - return this.value.equals(other.value); - } - - @Override - public int hashCode() { - return this.value.hashCode(); - } - - @JsonCreator(mode = JsonCreator.Mode.DELEGATING) - public static OptionalAlias of(@Nonnull Optional<@Safe String> value) { - return new OptionalAlias(value); - } - - public static OptionalAlias empty() { - return EMPTY; - } -} diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/OptionalExample.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/OptionalExample.java deleted file mode 100644 index 351a51d7d..000000000 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/OptionalExample.java +++ /dev/null @@ -1,210 +0,0 @@ -package undertow.com.palantir.product; - -import com.fasterxml.jackson.annotation.JsonIgnoreProperties; -import com.fasterxml.jackson.annotation.JsonInclude; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.fasterxml.jackson.annotation.JsonSetter; -import com.fasterxml.jackson.annotation.Nulls; -import com.fasterxml.jackson.databind.annotation.JsonDeserialize; -import com.google.errorprone.annotations.CheckReturnValue; -import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.SafeArg; -import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; -import java.util.ArrayList; -import java.util.List; -import java.util.Optional; -import java.util.function.Function; -import javax.annotation.Nonnull; -import javax.annotation.Nullable; -import javax.annotation.processing.Generated; - -@JsonDeserialize(builder = OptionalExample.Builder.class) -@Generated("com.palantir.conjure.java.types.BeanGenerator") -public final class OptionalExample { - private final Optional optionalString; - - private final Optional optionalObject; - - private final Optional> optionalCollection; - - private int memoizedHashCode; - - private OptionalExample( - Optional optionalString, - Optional optionalObject, - Optional> optionalCollection) { - validateFields(optionalString, optionalObject, optionalCollection); - this.optionalString = optionalString; - this.optionalObject = optionalObject; - this.optionalCollection = optionalCollection; - } - - @JsonProperty("optionalString") - @JsonInclude(JsonInclude.Include.NON_ABSENT) - public Optional getOptionalString() { - return this.optionalString; - } - - @JsonProperty("optionalObject") - @JsonInclude(JsonInclude.Include.NON_ABSENT) - public Optional getOptionalObject() { - return this.optionalObject; - } - - @JsonProperty("optionalCollection") - @JsonInclude(JsonInclude.Include.NON_ABSENT) - public Optional> getOptionalCollection() { - return this.optionalCollection; - } - - @Override - public boolean equals(@Nullable Object other) { - return this == other || (other instanceof OptionalExample && equalTo((OptionalExample) other)); - } - - private boolean equalTo(OptionalExample other) { - if (this.memoizedHashCode != 0 - && other.memoizedHashCode != 0 - && this.memoizedHashCode != other.memoizedHashCode) { - return false; - } - return this.optionalString.equals(other.optionalString) - && this.optionalObject.equals(other.optionalObject) - && this.optionalCollection.equals(other.optionalCollection); - } - - @Override - public int hashCode() { - int result = memoizedHashCode; - if (result == 0) { - int hash = 1; - hash = 31 * hash + this.optionalString.hashCode(); - hash = 31 * hash + this.optionalObject.hashCode(); - hash = 31 * hash + this.optionalCollection.hashCode(); - result = hash; - memoizedHashCode = result; - } - return result; - } - - @Override - public String toString() { - return "OptionalExample{optionalString: " + optionalString + ", optionalObject: " + optionalObject - + ", optionalCollection: " + optionalCollection + '}'; - } - - public static OptionalExample of( - String optionalString, ObjectReference optionalObject, List optionalCollection) { - return builder() - .optionalString(Optional.of(optionalString)) - .optionalObject(Optional.of(optionalObject)) - .optionalCollection(Optional.of(optionalCollection)) - .build(); - } - - private static void validateFields( - Optional optionalString, - Optional optionalObject, - Optional> optionalCollection) { - List missingFields = null; - missingFields = addFieldIfMissing(missingFields, optionalString, "optionalString"); - missingFields = addFieldIfMissing(missingFields, optionalObject, "optionalObject"); - missingFields = addFieldIfMissing(missingFields, optionalCollection, "optionalCollection"); - if (missingFields != null) { - throw new SafeIllegalArgumentException( - "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); - } - } - - private static List addFieldIfMissing(List prev, Object fieldValue, String fieldName) { - List missingFields = prev; - if (fieldValue == null) { - if (missingFields == null) { - missingFields = new ArrayList<>(3); - } - missingFields.add(fieldName); - } - return missingFields; - } - - public static Builder builder() { - return new Builder(); - } - - @Generated("com.palantir.conjure.java.types.BeanBuilderGenerator") - @JsonIgnoreProperties(ignoreUnknown = true) - public static final class Builder { - boolean _buildInvoked; - - private Optional optionalString = Optional.empty(); - - private Optional optionalObject = Optional.empty(); - - private Optional> optionalCollection = Optional.empty(); - - private Builder() {} - - public Builder from(OptionalExample other) { - checkNotBuilt(); - optionalString(other.getOptionalString()); - optionalObject(other.getOptionalObject()); - optionalCollection(other.getOptionalCollection()); - return this; - } - - @JsonSetter(value = "optionalString", nulls = Nulls.SKIP) - public Builder optionalString(@Nonnull Optional optionalString) { - checkNotBuilt(); - this.optionalString = Preconditions.checkNotNull(optionalString, "optionalString cannot be null"); - return this; - } - - public Builder optionalString(@Nonnull String optionalString) { - checkNotBuilt(); - this.optionalString = - Optional.of(Preconditions.checkNotNull(optionalString, "optionalString cannot be null")); - return this; - } - - @JsonSetter(value = "optionalObject", nulls = Nulls.SKIP) - public Builder optionalObject(@Nonnull Optional optionalObject) { - checkNotBuilt(); - this.optionalObject = Preconditions.checkNotNull(optionalObject, "optionalObject cannot be null"); - return this; - } - - public Builder optionalObject(@Nonnull ObjectReference optionalObject) { - checkNotBuilt(); - this.optionalObject = - Optional.of(Preconditions.checkNotNull(optionalObject, "optionalObject cannot be null")); - return this; - } - - @JsonSetter(value = "optionalCollection", nulls = Nulls.SKIP) - public Builder optionalCollection(@Nonnull Optional> optionalCollection) { - checkNotBuilt(); - this.optionalCollection = Preconditions.checkNotNull( - optionalCollection, "optionalCollection cannot be null") - .map(Function.identity()); - return this; - } - - public Builder optionalCollection(@Nonnull List optionalCollection) { - checkNotBuilt(); - this.optionalCollection = - Optional.of(Preconditions.checkNotNull(optionalCollection, "optionalCollection cannot be null")); - return this; - } - - @CheckReturnValue - public OptionalExample build() { - checkNotBuilt(); - this._buildInvoked = true; - return new OptionalExample(optionalString, optionalObject, optionalCollection); - } - - private void checkNotBuilt() { - Preconditions.checkState(!_buildInvoked, "Build has already been called"); - } - } -} diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/PrimitiveExample.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/PrimitiveExample.java deleted file mode 100644 index 290fa3728..000000000 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/PrimitiveExample.java +++ /dev/null @@ -1,345 +0,0 @@ -package undertow.com.palantir.product; - -import com.fasterxml.jackson.annotation.JsonIgnoreProperties; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.fasterxml.jackson.annotation.JsonSetter; -import com.fasterxml.jackson.databind.annotation.JsonDeserialize; -import com.google.errorprone.annotations.CheckReturnValue; -import com.palantir.conjure.java.lib.SafeLong; -import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.SafeArg; -import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; -import com.palantir.ri.ResourceIdentifier; -import java.nio.Buffer; -import java.nio.ByteBuffer; -import java.time.OffsetDateTime; -import java.util.ArrayList; -import java.util.List; -import java.util.UUID; -import javax.annotation.Nonnull; -import javax.annotation.Nullable; -import javax.annotation.processing.Generated; - -@JsonDeserialize(builder = PrimitiveExample.Builder.class) -@Generated("com.palantir.conjure.java.types.BeanGenerator") -public final class PrimitiveExample { - private final String stringVal; - - private final int intVal; - - private final SafeLong longVal; - - private final double doubleVal; - - private final boolean boolVal; - - private final ResourceIdentifier ridVal; - - private final UUID uuidVal; - - private final OffsetDateTime datetimeVal; - - private final ByteBuffer binaryVal; - - private int memoizedHashCode; - - private PrimitiveExample( - String stringVal, - int intVal, - SafeLong longVal, - double doubleVal, - boolean boolVal, - ResourceIdentifier ridVal, - UUID uuidVal, - OffsetDateTime datetimeVal, - ByteBuffer binaryVal) { - validateFields(stringVal, longVal, ridVal, uuidVal, datetimeVal, binaryVal); - this.stringVal = stringVal; - this.intVal = intVal; - this.longVal = longVal; - this.doubleVal = doubleVal; - this.boolVal = boolVal; - this.ridVal = ridVal; - this.uuidVal = uuidVal; - this.datetimeVal = datetimeVal; - this.binaryVal = binaryVal; - } - - @JsonProperty("stringVal") - public String getStringVal() { - return this.stringVal; - } - - @JsonProperty("intVal") - public int getIntVal() { - return this.intVal; - } - - @JsonProperty("longVal") - public SafeLong getLongVal() { - return this.longVal; - } - - @JsonProperty("doubleVal") - public double getDoubleVal() { - return this.doubleVal; - } - - @JsonProperty("boolVal") - public boolean getBoolVal() { - return this.boolVal; - } - - @JsonProperty("ridVal") - public ResourceIdentifier getRidVal() { - return this.ridVal; - } - - @JsonProperty("uuidVal") - public UUID getUuidVal() { - return this.uuidVal; - } - - @JsonProperty("datetimeVal") - public OffsetDateTime getDatetimeVal() { - return this.datetimeVal; - } - - @JsonProperty("binaryVal") - public ByteBuffer getBinaryVal() { - return this.binaryVal.asReadOnlyBuffer(); - } - - @Override - public boolean equals(@Nullable Object other) { - return this == other || (other instanceof PrimitiveExample && equalTo((PrimitiveExample) other)); - } - - private boolean equalTo(PrimitiveExample other) { - if (this.memoizedHashCode != 0 - && other.memoizedHashCode != 0 - && this.memoizedHashCode != other.memoizedHashCode) { - return false; - } - return this.stringVal.equals(other.stringVal) - && this.intVal == other.intVal - && this.longVal.equals(other.longVal) - && Double.doubleToLongBits(this.doubleVal) == Double.doubleToLongBits(other.doubleVal) - && this.boolVal == other.boolVal - && this.ridVal.equals(other.ridVal) - && this.uuidVal.equals(other.uuidVal) - && this.datetimeVal.isEqual(other.datetimeVal) - && this.binaryVal.equals(other.binaryVal); - } - - @Override - public int hashCode() { - int result = memoizedHashCode; - if (result == 0) { - int hash = 1; - hash = 31 * hash + this.stringVal.hashCode(); - hash = 31 * hash + this.intVal; - hash = 31 * hash + this.longVal.hashCode(); - hash = 31 * hash + Double.hashCode(this.doubleVal); - hash = 31 * hash + Boolean.hashCode(this.boolVal); - hash = 31 * hash + this.ridVal.hashCode(); - hash = 31 * hash + this.uuidVal.hashCode(); - hash = 31 * hash + this.datetimeVal.toInstant().hashCode(); - hash = 31 * hash + this.binaryVal.hashCode(); - result = hash; - memoizedHashCode = result; - } - return result; - } - - @Override - public String toString() { - return "PrimitiveExample{stringVal: " + stringVal + ", intVal: " + intVal + ", longVal: " + longVal - + ", doubleVal: " + doubleVal + ", boolVal: " + boolVal + ", ridVal: " + ridVal + ", uuidVal: " - + uuidVal + ", datetimeVal: " + datetimeVal + ", binaryVal: " + binaryVal + '}'; - } - - private static void validateFields( - String stringVal, - SafeLong longVal, - ResourceIdentifier ridVal, - UUID uuidVal, - OffsetDateTime datetimeVal, - ByteBuffer binaryVal) { - List missingFields = null; - missingFields = addFieldIfMissing(missingFields, stringVal, "stringVal"); - missingFields = addFieldIfMissing(missingFields, longVal, "longVal"); - missingFields = addFieldIfMissing(missingFields, ridVal, "ridVal"); - missingFields = addFieldIfMissing(missingFields, uuidVal, "uuidVal"); - missingFields = addFieldIfMissing(missingFields, datetimeVal, "datetimeVal"); - missingFields = addFieldIfMissing(missingFields, binaryVal, "binaryVal"); - if (missingFields != null) { - throw new SafeIllegalArgumentException( - "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); - } - } - - private static List addFieldIfMissing(List prev, Object fieldValue, String fieldName) { - List missingFields = prev; - if (fieldValue == null) { - if (missingFields == null) { - missingFields = new ArrayList<>(6); - } - missingFields.add(fieldName); - } - return missingFields; - } - - public static Builder builder() { - return new Builder(); - } - - @Generated("com.palantir.conjure.java.types.BeanBuilderGenerator") - @JsonIgnoreProperties(ignoreUnknown = true) - public static final class Builder { - boolean _buildInvoked; - - private String stringVal; - - private int intVal; - - private SafeLong longVal; - - private double doubleVal; - - private boolean boolVal; - - private ResourceIdentifier ridVal; - - private UUID uuidVal; - - private OffsetDateTime datetimeVal; - - private ByteBuffer binaryVal; - - private boolean _intValInitialized = false; - - private boolean _doubleValInitialized = false; - - private boolean _boolValInitialized = false; - - private Builder() {} - - public Builder from(PrimitiveExample other) { - checkNotBuilt(); - stringVal(other.getStringVal()); - intVal(other.getIntVal()); - longVal(other.getLongVal()); - doubleVal(other.getDoubleVal()); - boolVal(other.getBoolVal()); - ridVal(other.getRidVal()); - uuidVal(other.getUuidVal()); - datetimeVal(other.getDatetimeVal()); - binaryVal(other.getBinaryVal()); - return this; - } - - @JsonSetter("stringVal") - public Builder stringVal(@Nonnull String stringVal) { - checkNotBuilt(); - this.stringVal = Preconditions.checkNotNull(stringVal, "stringVal cannot be null"); - return this; - } - - @JsonSetter("intVal") - public Builder intVal(int intVal) { - checkNotBuilt(); - this.intVal = intVal; - this._intValInitialized = true; - return this; - } - - @JsonSetter("longVal") - public Builder longVal(@Nonnull SafeLong longVal) { - checkNotBuilt(); - this.longVal = Preconditions.checkNotNull(longVal, "longVal cannot be null"); - return this; - } - - @JsonSetter("doubleVal") - public Builder doubleVal(double doubleVal) { - checkNotBuilt(); - this.doubleVal = doubleVal; - this._doubleValInitialized = true; - return this; - } - - @JsonSetter("boolVal") - public Builder boolVal(boolean boolVal) { - checkNotBuilt(); - this.boolVal = boolVal; - this._boolValInitialized = true; - return this; - } - - @JsonSetter("ridVal") - public Builder ridVal(@Nonnull ResourceIdentifier ridVal) { - checkNotBuilt(); - this.ridVal = Preconditions.checkNotNull(ridVal, "ridVal cannot be null"); - return this; - } - - @JsonSetter("uuidVal") - public Builder uuidVal(@Nonnull UUID uuidVal) { - checkNotBuilt(); - this.uuidVal = Preconditions.checkNotNull(uuidVal, "uuidVal cannot be null"); - return this; - } - - @JsonSetter("datetimeVal") - public Builder datetimeVal(@Nonnull OffsetDateTime datetimeVal) { - checkNotBuilt(); - this.datetimeVal = Preconditions.checkNotNull(datetimeVal, "datetimeVal cannot be null"); - return this; - } - - @JsonSetter("binaryVal") - public Builder binaryVal(@Nonnull ByteBuffer binaryVal) { - checkNotBuilt(); - Preconditions.checkNotNull(binaryVal, "binaryVal cannot be null"); - this.binaryVal = ByteBuffer.allocate(binaryVal.remaining()).put(binaryVal.duplicate()); - ((Buffer) this.binaryVal).rewind(); - return this; - } - - private void validatePrimitiveFieldsHaveBeenInitialized() { - List missingFields = null; - missingFields = addFieldIfMissing(missingFields, _intValInitialized, "intVal"); - missingFields = addFieldIfMissing(missingFields, _doubleValInitialized, "doubleVal"); - missingFields = addFieldIfMissing(missingFields, _boolValInitialized, "boolVal"); - if (missingFields != null) { - throw new SafeIllegalArgumentException( - "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); - } - } - - private static List addFieldIfMissing(List prev, boolean initialized, String fieldName) { - List missingFields = prev; - if (!initialized) { - if (missingFields == null) { - missingFields = new ArrayList<>(3); - } - missingFields.add(fieldName); - } - return missingFields; - } - - @CheckReturnValue - public PrimitiveExample build() { - checkNotBuilt(); - this._buildInvoked = true; - validatePrimitiveFieldsHaveBeenInitialized(); - return new PrimitiveExample( - stringVal, intVal, longVal, doubleVal, boolVal, ridVal, uuidVal, datetimeVal, binaryVal); - } - - private void checkNotBuilt() { - Preconditions.checkState(!_buildInvoked, "Build has already been called"); - } - } -} diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/SafetyExample.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/SafetyExample.java deleted file mode 100644 index 08998d310..000000000 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/SafetyExample.java +++ /dev/null @@ -1,176 +0,0 @@ -package undertow.com.palantir.product; - -import com.fasterxml.jackson.annotation.JsonIgnoreProperties; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.fasterxml.jackson.annotation.JsonSetter; -import com.fasterxml.jackson.databind.annotation.JsonDeserialize; -import com.google.errorprone.annotations.CheckReturnValue; -import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.Safe; -import com.palantir.logsafe.SafeArg; -import com.palantir.logsafe.Unsafe; -import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; -import java.util.ArrayList; -import java.util.List; -import javax.annotation.Nonnull; -import javax.annotation.Nullable; -import javax.annotation.processing.Generated; - -@Unsafe -@JsonDeserialize(builder = SafetyExample.Builder.class) -@Generated("com.palantir.conjure.java.types.BeanGenerator") -public final class SafetyExample { - private final String safeString; - - private final double unsafeDouble; - - private int memoizedHashCode; - - private SafetyExample(String safeString, double unsafeDouble) { - validateFields(safeString); - this.safeString = safeString; - this.unsafeDouble = unsafeDouble; - } - - @JsonProperty("safeString") - @Safe - public String getSafeString() { - return this.safeString; - } - - @JsonProperty("unsafeDouble") - @Unsafe - public double getUnsafeDouble() { - return this.unsafeDouble; - } - - @Override - public boolean equals(@Nullable Object other) { - return this == other || (other instanceof SafetyExample && equalTo((SafetyExample) other)); - } - - private boolean equalTo(SafetyExample other) { - if (this.memoizedHashCode != 0 - && other.memoizedHashCode != 0 - && this.memoizedHashCode != other.memoizedHashCode) { - return false; - } - return this.safeString.equals(other.safeString) - && Double.doubleToLongBits(this.unsafeDouble) == Double.doubleToLongBits(other.unsafeDouble); - } - - @Override - public int hashCode() { - int result = memoizedHashCode; - if (result == 0) { - int hash = 1; - hash = 31 * hash + this.safeString.hashCode(); - hash = 31 * hash + Double.hashCode(this.unsafeDouble); - result = hash; - memoizedHashCode = result; - } - return result; - } - - @Override - @Unsafe - public String toString() { - return "SafetyExample{safeString: " + safeString + ", unsafeDouble: " + unsafeDouble + '}'; - } - - public static SafetyExample of(@Safe String safeString, @Unsafe double unsafeDouble) { - return builder().safeString(safeString).unsafeDouble(unsafeDouble).build(); - } - - private static void validateFields(String safeString) { - List missingFields = null; - missingFields = addFieldIfMissing(missingFields, safeString, "safeString"); - if (missingFields != null) { - throw new SafeIllegalArgumentException( - "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); - } - } - - private static List addFieldIfMissing(List prev, Object fieldValue, String fieldName) { - List missingFields = prev; - if (fieldValue == null) { - if (missingFields == null) { - missingFields = new ArrayList<>(1); - } - missingFields.add(fieldName); - } - return missingFields; - } - - public static Builder builder() { - return new Builder(); - } - - @Generated("com.palantir.conjure.java.types.BeanBuilderGenerator") - @JsonIgnoreProperties(ignoreUnknown = true) - public static final class Builder { - boolean _buildInvoked; - - private @Safe String safeString; - - private @Unsafe double unsafeDouble; - - private boolean _unsafeDoubleInitialized = false; - - private Builder() {} - - public Builder from(SafetyExample other) { - checkNotBuilt(); - safeString(other.getSafeString()); - unsafeDouble(other.getUnsafeDouble()); - return this; - } - - @JsonSetter("safeString") - public Builder safeString(@Nonnull @Safe String safeString) { - checkNotBuilt(); - this.safeString = Preconditions.checkNotNull(safeString, "safeString cannot be null"); - return this; - } - - @JsonSetter("unsafeDouble") - public Builder unsafeDouble(@Unsafe double unsafeDouble) { - checkNotBuilt(); - this.unsafeDouble = unsafeDouble; - this._unsafeDoubleInitialized = true; - return this; - } - - private void validatePrimitiveFieldsHaveBeenInitialized() { - List missingFields = null; - missingFields = addFieldIfMissing(missingFields, _unsafeDoubleInitialized, "unsafeDouble"); - if (missingFields != null) { - throw new SafeIllegalArgumentException( - "Some required fields have not been set", SafeArg.of("missingFields", missingFields)); - } - } - - private static List addFieldIfMissing(List prev, boolean initialized, String fieldName) { - List missingFields = prev; - if (!initialized) { - if (missingFields == null) { - missingFields = new ArrayList<>(1); - } - missingFields.add(fieldName); - } - return missingFields; - } - - @CheckReturnValue - public SafetyExample build() { - checkNotBuilt(); - this._buildInvoked = true; - validatePrimitiveFieldsHaveBeenInitialized(); - return new SafetyExample(safeString, unsafeDouble); - } - - private void checkNotBuilt() { - Preconditions.checkState(!_buildInvoked, "Build has already been called"); - } - } -} diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/StringAliasEx.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/StringAliasEx.java deleted file mode 100644 index 2c1c6645e..000000000 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/StringAliasEx.java +++ /dev/null @@ -1,58 +0,0 @@ -package undertow.com.palantir.product; - -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonValue; -import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.Safe; -import javax.annotation.Nonnull; -import javax.annotation.Nullable; -import javax.annotation.processing.Generated; - -@Safe -@Generated("com.palantir.conjure.java.types.AliasGenerator") -public final class StringAliasEx implements Comparable { - private final @Safe String value; - - private StringAliasEx(@Nonnull @Safe String value) { - this.value = Preconditions.checkNotNull(value, "value cannot be null"); - } - - @JsonValue - public @Safe String get() { - return value; - } - - @Override - @Safe - public String toString() { - return value.toString(); - } - - @Override - public boolean equals(@Nullable Object other) { - return this == other || (other instanceof StringAliasEx && equalTo((StringAliasEx) other)); - } - - private boolean equalTo(StringAliasEx other) { - return this.value.equals(other.value); - } - - @Override - public int hashCode() { - return this.value.hashCode(); - } - - @Override - public int compareTo(StringAliasEx other) { - return value.compareTo(other.get()); - } - - public static StringAliasEx valueOf(@Safe String value) { - return of(value); - } - - @JsonCreator(mode = JsonCreator.Mode.DELEGATING) - public static StringAliasEx of(@Nonnull @Safe String value) { - return new StringAliasEx(value); - } -} diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/UnionExample.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/UnionExample.java deleted file mode 100644 index 4892a4eca..000000000 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/UnionExample.java +++ /dev/null @@ -1,579 +0,0 @@ -package undertow.com.palantir.product; - -import com.fasterxml.jackson.annotation.JsonAnyGetter; -import com.fasterxml.jackson.annotation.JsonAnySetter; -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonIgnoreProperties; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.fasterxml.jackson.annotation.JsonSetter; -import com.fasterxml.jackson.annotation.JsonSubTypes; -import com.fasterxml.jackson.annotation.JsonTypeInfo; -import com.fasterxml.jackson.annotation.JsonTypeName; -import com.fasterxml.jackson.annotation.JsonValue; -import com.fasterxml.jackson.annotation.Nulls; -import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.Safe; -import com.palantir.logsafe.SafeArg; -import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.Optional; -import java.util.function.Function; -import java.util.function.IntFunction; -import javax.annotation.Nonnull; -import javax.annotation.Nullable; -import javax.annotation.processing.Generated; - -@Generated("com.palantir.conjure.java.types.UnionGenerator") -public final class UnionExample { - private final Base value; - - @JsonCreator(mode = JsonCreator.Mode.DELEGATING) - private UnionExample(Base value) { - this.value = value; - } - - @JsonValue - private Base getValue() { - return value; - } - - public static UnionExample stringVariant(String value) { - return new UnionExample(new StringVariantWrapper(value)); - } - - public static UnionExample intVariant(int value) { - return new UnionExample(new IntVariantWrapper(value)); - } - - public static UnionExample objectVariant(ObjectReference value) { - return new UnionExample(new ObjectVariantWrapper(value)); - } - - public static UnionExample collectionVariant(List value) { - return new UnionExample(new CollectionVariantWrapper(value)); - } - - public static UnionExample optionalVariant(Optional value) { - return new UnionExample(new OptionalVariantWrapper(value)); - } - - public static UnionExample unknown(@Safe String type, Object value) { - switch (Preconditions.checkNotNull(type, "Type is required")) { - case "stringVariant": - throw new SafeIllegalArgumentException( - "Unknown type cannot be created as the provided type is known: stringVariant"); - case "intVariant": - throw new SafeIllegalArgumentException( - "Unknown type cannot be created as the provided type is known: intVariant"); - case "objectVariant": - throw new SafeIllegalArgumentException( - "Unknown type cannot be created as the provided type is known: objectVariant"); - case "collectionVariant": - throw new SafeIllegalArgumentException( - "Unknown type cannot be created as the provided type is known: collectionVariant"); - case "optionalVariant": - throw new SafeIllegalArgumentException( - "Unknown type cannot be created as the provided type is known: optionalVariant"); - default: - return new UnionExample(new UnknownWrapper(type, Collections.singletonMap(type, value))); - } - } - - public T accept(Visitor visitor) { - return value.accept(visitor); - } - - @Override - public boolean equals(@Nullable Object other) { - return this == other || (other instanceof UnionExample && equalTo((UnionExample) other)); - } - - private boolean equalTo(UnionExample other) { - return this.value.equals(other.value); - } - - @Override - public int hashCode() { - return this.value.hashCode(); - } - - @Override - public String toString() { - return "UnionExample{value: " + value + '}'; - } - - public interface Visitor { - T visitStringVariant(String value); - - T visitIntVariant(int value); - - T visitObjectVariant(ObjectReference value); - - T visitCollectionVariant(List value); - - T visitOptionalVariant(Optional value); - - T visitUnknown(@Safe String unknownType); - - static CollectionVariantStageVisitorBuilder builder() { - return new VisitorBuilder(); - } - } - - private static final class VisitorBuilder - implements CollectionVariantStageVisitorBuilder, - IntVariantStageVisitorBuilder, - ObjectVariantStageVisitorBuilder, - OptionalVariantStageVisitorBuilder, - StringVariantStageVisitorBuilder, - UnknownStageVisitorBuilder, - Completed_StageVisitorBuilder { - private Function, T> collectionVariantVisitor; - - private IntFunction intVariantVisitor; - - private Function objectVariantVisitor; - - private Function, T> optionalVariantVisitor; - - private Function stringVariantVisitor; - - private Function unknownVisitor; - - @Override - public IntVariantStageVisitorBuilder collectionVariant( - @Nonnull Function, T> collectionVariantVisitor) { - Preconditions.checkNotNull(collectionVariantVisitor, "collectionVariantVisitor cannot be null"); - this.collectionVariantVisitor = collectionVariantVisitor; - return this; - } - - @Override - public ObjectVariantStageVisitorBuilder intVariant(@Nonnull IntFunction intVariantVisitor) { - Preconditions.checkNotNull(intVariantVisitor, "intVariantVisitor cannot be null"); - this.intVariantVisitor = intVariantVisitor; - return this; - } - - @Override - public OptionalVariantStageVisitorBuilder objectVariant( - @Nonnull Function objectVariantVisitor) { - Preconditions.checkNotNull(objectVariantVisitor, "objectVariantVisitor cannot be null"); - this.objectVariantVisitor = objectVariantVisitor; - return this; - } - - @Override - public StringVariantStageVisitorBuilder optionalVariant( - @Nonnull Function, T> optionalVariantVisitor) { - Preconditions.checkNotNull(optionalVariantVisitor, "optionalVariantVisitor cannot be null"); - this.optionalVariantVisitor = optionalVariantVisitor; - return this; - } - - @Override - public UnknownStageVisitorBuilder stringVariant(@Nonnull Function stringVariantVisitor) { - Preconditions.checkNotNull(stringVariantVisitor, "stringVariantVisitor cannot be null"); - this.stringVariantVisitor = stringVariantVisitor; - return this; - } - - @Override - public Completed_StageVisitorBuilder unknown(@Nonnull Function unknownVisitor) { - Preconditions.checkNotNull(unknownVisitor, "unknownVisitor cannot be null"); - this.unknownVisitor = unknownVisitor; - return this; - } - - @Override - public Completed_StageVisitorBuilder throwOnUnknown() { - this.unknownVisitor = unknownType -> { - throw new SafeIllegalArgumentException( - "Unknown variant of the 'UnionExample' union", SafeArg.of("unknownType", unknownType)); - }; - return this; - } - - @Override - public Visitor build() { - final Function, T> collectionVariantVisitor = this.collectionVariantVisitor; - final IntFunction intVariantVisitor = this.intVariantVisitor; - final Function objectVariantVisitor = this.objectVariantVisitor; - final Function, T> optionalVariantVisitor = this.optionalVariantVisitor; - final Function stringVariantVisitor = this.stringVariantVisitor; - final Function unknownVisitor = this.unknownVisitor; - return new Visitor() { - @Override - public T visitCollectionVariant(List value) { - return collectionVariantVisitor.apply(value); - } - - @Override - public T visitIntVariant(int value) { - return intVariantVisitor.apply(value); - } - - @Override - public T visitObjectVariant(ObjectReference value) { - return objectVariantVisitor.apply(value); - } - - @Override - public T visitOptionalVariant(Optional value) { - return optionalVariantVisitor.apply(value); - } - - @Override - public T visitStringVariant(String value) { - return stringVariantVisitor.apply(value); - } - - @Override - public T visitUnknown(String value) { - return unknownVisitor.apply(value); - } - }; - } - } - - public interface CollectionVariantStageVisitorBuilder { - IntVariantStageVisitorBuilder collectionVariant(@Nonnull Function, T> collectionVariantVisitor); - } - - public interface IntVariantStageVisitorBuilder { - ObjectVariantStageVisitorBuilder intVariant(@Nonnull IntFunction intVariantVisitor); - } - - public interface ObjectVariantStageVisitorBuilder { - OptionalVariantStageVisitorBuilder objectVariant(@Nonnull Function objectVariantVisitor); - } - - public interface OptionalVariantStageVisitorBuilder { - StringVariantStageVisitorBuilder optionalVariant( - @Nonnull Function, T> optionalVariantVisitor); - } - - public interface StringVariantStageVisitorBuilder { - UnknownStageVisitorBuilder stringVariant(@Nonnull Function stringVariantVisitor); - } - - public interface UnknownStageVisitorBuilder { - Completed_StageVisitorBuilder unknown(@Nonnull Function unknownVisitor); - - Completed_StageVisitorBuilder throwOnUnknown(); - } - - public interface Completed_StageVisitorBuilder { - Visitor build(); - } - - @JsonTypeInfo( - use = JsonTypeInfo.Id.NAME, - include = JsonTypeInfo.As.EXISTING_PROPERTY, - property = "type", - visible = true, - defaultImpl = UnknownWrapper.class) - @JsonSubTypes({ - @JsonSubTypes.Type(StringVariantWrapper.class), - @JsonSubTypes.Type(IntVariantWrapper.class), - @JsonSubTypes.Type(ObjectVariantWrapper.class), - @JsonSubTypes.Type(CollectionVariantWrapper.class), - @JsonSubTypes.Type(OptionalVariantWrapper.class) - }) - @JsonIgnoreProperties(ignoreUnknown = true) - private interface Base { - T accept(Visitor visitor); - } - - @JsonTypeName("stringVariant") - private static final class StringVariantWrapper implements Base { - private final String value; - - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - private StringVariantWrapper(@JsonSetter("stringVariant") @Nonnull String value) { - Preconditions.checkNotNull(value, "stringVariant cannot be null"); - this.value = value; - } - - @JsonProperty(value = "type", index = 0) - private String getType() { - return "stringVariant"; - } - - @JsonProperty("stringVariant") - private String getValue() { - return value; - } - - @Override - public T accept(Visitor visitor) { - return visitor.visitStringVariant(value); - } - - @Override - public boolean equals(@Nullable Object other) { - return this == other || (other instanceof StringVariantWrapper && equalTo((StringVariantWrapper) other)); - } - - private boolean equalTo(StringVariantWrapper other) { - return this.value.equals(other.value); - } - - @Override - public int hashCode() { - return this.value.hashCode(); - } - - @Override - public String toString() { - return "StringVariantWrapper{value: " + value + '}'; - } - } - - @JsonTypeName("intVariant") - private static final class IntVariantWrapper implements Base { - private final int value; - - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - private IntVariantWrapper(@JsonSetter("intVariant") @Nonnull int value) { - Preconditions.checkNotNull(value, "intVariant cannot be null"); - this.value = value; - } - - @JsonProperty(value = "type", index = 0) - private String getType() { - return "intVariant"; - } - - @JsonProperty("intVariant") - private int getValue() { - return value; - } - - @Override - public T accept(Visitor visitor) { - return visitor.visitIntVariant(value); - } - - @Override - public boolean equals(@Nullable Object other) { - return this == other || (other instanceof IntVariantWrapper && equalTo((IntVariantWrapper) other)); - } - - private boolean equalTo(IntVariantWrapper other) { - return this.value == other.value; - } - - @Override - public int hashCode() { - return this.value; - } - - @Override - public String toString() { - return "IntVariantWrapper{value: " + value + '}'; - } - } - - @JsonTypeName("objectVariant") - private static final class ObjectVariantWrapper implements Base { - private final ObjectReference value; - - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - private ObjectVariantWrapper(@JsonSetter("objectVariant") @Nonnull ObjectReference value) { - Preconditions.checkNotNull(value, "objectVariant cannot be null"); - this.value = value; - } - - @JsonProperty(value = "type", index = 0) - private String getType() { - return "objectVariant"; - } - - @JsonProperty("objectVariant") - private ObjectReference getValue() { - return value; - } - - @Override - public T accept(Visitor visitor) { - return visitor.visitObjectVariant(value); - } - - @Override - public boolean equals(@Nullable Object other) { - return this == other || (other instanceof ObjectVariantWrapper && equalTo((ObjectVariantWrapper) other)); - } - - private boolean equalTo(ObjectVariantWrapper other) { - return this.value.equals(other.value); - } - - @Override - public int hashCode() { - return this.value.hashCode(); - } - - @Override - public String toString() { - return "ObjectVariantWrapper{value: " + value + '}'; - } - } - - @JsonTypeName("collectionVariant") - private static final class CollectionVariantWrapper implements Base { - private final List value; - - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - private CollectionVariantWrapper( - @JsonSetter(value = "collectionVariant", nulls = Nulls.AS_EMPTY) @Nonnull List value) { - Preconditions.checkNotNull(value, "collectionVariant cannot be null"); - this.value = value; - } - - @JsonProperty(value = "type", index = 0) - private String getType() { - return "collectionVariant"; - } - - @JsonProperty("collectionVariant") - private List getValue() { - return value; - } - - @Override - public T accept(Visitor visitor) { - return visitor.visitCollectionVariant(value); - } - - @Override - public boolean equals(@Nullable Object other) { - return this == other - || (other instanceof CollectionVariantWrapper && equalTo((CollectionVariantWrapper) other)); - } - - private boolean equalTo(CollectionVariantWrapper other) { - return this.value.equals(other.value); - } - - @Override - public int hashCode() { - return this.value.hashCode(); - } - - @Override - public String toString() { - return "CollectionVariantWrapper{value: " + value + '}'; - } - } - - @JsonTypeName("optionalVariant") - private static final class OptionalVariantWrapper implements Base { - private final Optional value; - - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - private OptionalVariantWrapper( - @JsonSetter(value = "optionalVariant", nulls = Nulls.AS_EMPTY) @Nonnull Optional value) { - Preconditions.checkNotNull(value, "optionalVariant cannot be null"); - this.value = value; - } - - @JsonProperty(value = "type", index = 0) - private String getType() { - return "optionalVariant"; - } - - @JsonProperty("optionalVariant") - private Optional getValue() { - return value; - } - - @Override - public T accept(Visitor visitor) { - return visitor.visitOptionalVariant(value); - } - - @Override - public boolean equals(@Nullable Object other) { - return this == other - || (other instanceof OptionalVariantWrapper && equalTo((OptionalVariantWrapper) other)); - } - - private boolean equalTo(OptionalVariantWrapper other) { - return this.value.equals(other.value); - } - - @Override - public int hashCode() { - return this.value.hashCode(); - } - - @Override - public String toString() { - return "OptionalVariantWrapper{value: " + value + '}'; - } - } - - private static final class UnknownWrapper implements Base { - private final String type; - - private final Map value; - - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - private UnknownWrapper(@JsonProperty("type") String type) { - this(type, new HashMap()); - } - - private UnknownWrapper(@Nonnull String type, @Nonnull Map value) { - Preconditions.checkNotNull(type, "type cannot be null"); - Preconditions.checkNotNull(value, "value cannot be null"); - this.type = type; - this.value = value; - } - - @JsonProperty - private String getType() { - return type; - } - - @JsonAnyGetter - private Map getValue() { - return value; - } - - @JsonAnySetter - private void put(String key, Object val) { - value.put(key, val); - } - - @Override - public T accept(Visitor visitor) { - return visitor.visitUnknown(type); - } - - @Override - public boolean equals(@Nullable Object other) { - return this == other || (other instanceof UnknownWrapper && equalTo((UnknownWrapper) other)); - } - - private boolean equalTo(UnknownWrapper other) { - return this.type.equals(other.type) && this.value.equals(other.value); - } - - @Override - public int hashCode() { - int hash = 1; - hash = 31 * hash + this.type.hashCode(); - hash = 31 * hash + this.value.hashCode(); - return hash; - } - - @Override - public String toString() { - return "UnknownWrapper{type: " + type + ", value: " + value + '}'; - } - } -} diff --git a/conjure-java-core/src/test/resources/ete-service.yml b/conjure-java-core/src/test/resources/ete-service.yml index 38df0d8ae..9f82a7ff7 100644 --- a/conjure-java-core/src/test/resources/ete-service.yml +++ b/conjure-java-core/src/test/resources/ete-service.yml @@ -1,8 +1,4 @@ types: - # This is needed because Conjure needs to know the errors that could be thrown. Every error defined in the imported - # files that is part of the same package as a service will be respected. - conjure-imports: - errors: example-errors.yml imports: StringAliasExampleImport: base-type: string From 5ca715e7becdf6cf86ea443518329da3cd7fdbb4 Mon Sep 17 00:00:00 2001 From: Pritham Marupaka Date: Wed, 13 Aug 2025 14:17:27 -0400 Subject: [PATCH 11/26] update to use ExceptionDeserializerArgs --- .../product/EmptyPathServiceAsync.java | 7 +- .../product/EmptyPathServiceBlocking.java | 7 +- .../com/palantir/product/EteServiceAsync.java | 163 +++++++----------- .../palantir/product/EteServiceBlocking.java | 163 +++++++----------- .../dialogue/test/api/CookieServiceAsync.java | 7 +- .../test/api/CookieServiceBlocking.java | 7 +- versions.lock | 6 +- versions.props | 2 +- 8 files changed, 148 insertions(+), 214 deletions(-) diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceAsync.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceAsync.java index 599dc7084..a808a8132 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceAsync.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceAsync.java @@ -5,12 +5,12 @@ import com.palantir.dialogue.Channel; import com.palantir.dialogue.ConjureRuntime; import com.palantir.dialogue.Deserializer; -import com.palantir.dialogue.DeserializerArgs; import com.palantir.dialogue.DialogueService; import com.palantir.dialogue.DialogueServiceFactory; import com.palantir.dialogue.Endpoint; import com.palantir.dialogue.EndpointChannel; import com.palantir.dialogue.EndpointChannelFactory; +import com.palantir.dialogue.ExceptionDeserializerArgs; import com.palantir.dialogue.PlainSerDe; import com.palantir.dialogue.Request; import com.palantir.dialogue.TypeMarker; @@ -35,9 +35,8 @@ static EmptyPathServiceAsync of(EndpointChannelFactory _endpointChannelFactory, _endpointChannelFactory.endpoint(DialogueEmptyPathEndpoints.emptyPath); private final Deserializer emptyPathDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceBlocking.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceBlocking.java index 646d1c606..c8d1ef041 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceBlocking.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceBlocking.java @@ -4,12 +4,12 @@ import com.palantir.dialogue.Channel; import com.palantir.dialogue.ConjureRuntime; import com.palantir.dialogue.Deserializer; -import com.palantir.dialogue.DeserializerArgs; import com.palantir.dialogue.DialogueService; import com.palantir.dialogue.DialogueServiceFactory; import com.palantir.dialogue.Endpoint; import com.palantir.dialogue.EndpointChannel; import com.palantir.dialogue.EndpointChannelFactory; +import com.palantir.dialogue.ExceptionDeserializerArgs; import com.palantir.dialogue.PlainSerDe; import com.palantir.dialogue.Request; import com.palantir.dialogue.TypeMarker; @@ -34,9 +34,8 @@ static EmptyPathServiceBlocking of(EndpointChannelFactory _endpointChannelFactor _endpointChannelFactory.endpoint(DialogueEmptyPathEndpoints.emptyPath); private final Deserializer emptyPathDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceAsync.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceAsync.java index 60313fdd1..3b1fb425b 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceAsync.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceAsync.java @@ -6,12 +6,12 @@ import com.palantir.dialogue.Channel; import com.palantir.dialogue.ConjureRuntime; import com.palantir.dialogue.Deserializer; -import com.palantir.dialogue.DeserializerArgs; import com.palantir.dialogue.DialogueService; import com.palantir.dialogue.DialogueServiceFactory; import com.palantir.dialogue.Endpoint; import com.palantir.dialogue.EndpointChannel; import com.palantir.dialogue.EndpointChannelFactory; +import com.palantir.dialogue.ExceptionDeserializerArgs; import com.palantir.dialogue.PlainSerDe; import com.palantir.dialogue.Request; import com.palantir.dialogue.Serializer; @@ -220,9 +220,8 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur private final EndpointChannel stringChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.string); private final Deserializer stringDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -253,9 +252,8 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur _endpointChannelFactory.endpoint(DialogueEteEndpoints.integer); private final Deserializer integerDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -286,9 +284,8 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur _endpointChannelFactory.endpoint(DialogueEteEndpoints.double_); private final Deserializer double_Deserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -319,9 +316,8 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur _endpointChannelFactory.endpoint(DialogueEteEndpoints.boolean_); private final Deserializer boolean_Deserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -352,9 +348,8 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur _endpointChannelFactory.endpoint(DialogueEteEndpoints.safelong); private final Deserializer safelongDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -384,9 +379,8 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur private final EndpointChannel ridChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.rid); private final Deserializer ridDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -417,9 +411,8 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur _endpointChannelFactory.endpoint(DialogueEteEndpoints.bearertoken); private final Deserializer bearertokenDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -450,9 +443,8 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalString); private final Deserializer> optionalStringDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.>builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker>() {}) + .deserializer(ExceptionDeserializerArgs.>builder() + .returnType(new TypeMarker>() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -483,9 +475,8 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalEmpty); private final Deserializer> optionalEmptyDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.>builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker>() {}) + .deserializer(ExceptionDeserializerArgs.>builder() + .returnType(new TypeMarker>() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -516,9 +507,8 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur _endpointChannelFactory.endpoint(DialogueEteEndpoints.datetime); private final Deserializer datetimeDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -550,9 +540,8 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur private final EndpointChannel pathChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.path); private final Deserializer pathDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -583,9 +572,8 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur _endpointChannelFactory.endpoint(DialogueEteEndpoints.externalLongPath); private final Deserializer externalLongPathDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -616,9 +604,8 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalExternalLongQuery); private final Deserializer> optionalExternalLongQueryDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.>builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker>() {}) + .deserializer(ExceptionDeserializerArgs.>builder() + .returnType(new TypeMarker>() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -652,9 +639,8 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur _endpointChannelFactory.endpoint(DialogueEteEndpoints.notNullBody); private final Deserializer notNullBodyDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -685,9 +671,8 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur _endpointChannelFactory.endpoint(DialogueEteEndpoints.aliasOne); private final Deserializer aliasOneDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -718,9 +703,8 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalAliasOne); private final Deserializer optionalAliasOneDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -751,9 +735,8 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur _endpointChannelFactory.endpoint(DialogueEteEndpoints.aliasTwo); private final Deserializer aliasTwoDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -790,9 +773,9 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur private final Deserializer notNullBodyExternalImportDeserializer = _runtime.bodySerDe() .deserializer( - DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success( + ExceptionDeserializerArgs + .builder() + .returnType( new TypeMarker< allexamples.com.palantir.product.StringAliasExample>() {}) .exception( @@ -845,10 +828,9 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur private final Deserializer> optionalBodyExternalImportDeserializer = _runtime.bodySerDe() .deserializer( - DeserializerArgs + ExceptionDeserializerArgs .>builder() - .baseType(new TypeMarker<>() {}) - .success( + .returnType( new TypeMarker< Optional< allexamples.com.palantir.product @@ -898,10 +880,9 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur private final Deserializer> optionalQueryExternalImportDeserializer = _runtime.bodySerDe() .deserializer( - DeserializerArgs + ExceptionDeserializerArgs .>builder() - .baseType(new TypeMarker<>() {}) - .success( + .returnType( new TypeMarker< Optional< allexamples.com.palantir.product @@ -949,9 +930,8 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur _endpointChannelFactory.endpoint(DialogueEteEndpoints.noReturn); private final Deserializer noReturnDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -982,9 +962,8 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur _endpointChannelFactory.endpoint(DialogueEteEndpoints.enumQuery); private final Deserializer enumQueryDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -1015,9 +994,8 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur _endpointChannelFactory.endpoint(DialogueEteEndpoints.enumListQuery); private final Deserializer> enumListQueryDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.>builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker>() {}) + .deserializer(ExceptionDeserializerArgs.>builder() + .returnType(new TypeMarker>() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -1048,9 +1026,8 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalEnumQuery); private final Deserializer> optionalEnumQueryDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.>builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker>() {}) + .deserializer(ExceptionDeserializerArgs.>builder() + .returnType(new TypeMarker>() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -1081,9 +1058,8 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur _endpointChannelFactory.endpoint(DialogueEteEndpoints.enumHeader); private final Deserializer enumHeaderDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -1114,9 +1090,8 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur _endpointChannelFactory.endpoint(DialogueEteEndpoints.jsonErrorsHeader); private final Deserializer jsonErrorsHeaderDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -1147,9 +1122,8 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur _endpointChannelFactory.endpoint(DialogueEteEndpoints.errorParameterSerialization); private final Deserializer errorParameterSerializationDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -1180,9 +1154,8 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur _endpointChannelFactory.endpoint(DialogueEteEndpoints.aliasLongEndpoint); private final Deserializer> aliasLongEndpointDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.>builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker>() {}) + .deserializer(ExceptionDeserializerArgs.>builder() + .returnType(new TypeMarker>() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -1213,9 +1186,8 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur _endpointChannelFactory.endpoint(DialogueEteEndpoints.complexQueryParameters); private final Deserializer complexQueryParametersDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -1249,9 +1221,8 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur _endpointChannelFactory.endpoint(DialogueEteEndpoints.receiveListOfOptionals); private final Deserializer receiveListOfOptionalsDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -1285,9 +1256,8 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur _endpointChannelFactory.endpoint(DialogueEteEndpoints.receiveSetOfOptionals); private final Deserializer receiveSetOfOptionalsDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -1321,9 +1291,8 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur _endpointChannelFactory.endpoint(DialogueEteEndpoints.receiveListOfStrings); private final Deserializer receiveListOfStringsDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceBlocking.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceBlocking.java index 54254d884..979d55d1d 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceBlocking.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceBlocking.java @@ -6,12 +6,12 @@ import com.palantir.dialogue.Channel; import com.palantir.dialogue.ConjureRuntime; import com.palantir.dialogue.Deserializer; -import com.palantir.dialogue.DeserializerArgs; import com.palantir.dialogue.DialogueService; import com.palantir.dialogue.DialogueServiceFactory; import com.palantir.dialogue.Endpoint; import com.palantir.dialogue.EndpointChannel; import com.palantir.dialogue.EndpointChannelFactory; +import com.palantir.dialogue.ExceptionDeserializerArgs; import com.palantir.dialogue.PlainSerDe; import com.palantir.dialogue.Request; import com.palantir.dialogue.Serializer; @@ -219,9 +219,8 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con private final EndpointChannel stringChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.string); private final Deserializer stringDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -252,9 +251,8 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con _endpointChannelFactory.endpoint(DialogueEteEndpoints.integer); private final Deserializer integerDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -285,9 +283,8 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con _endpointChannelFactory.endpoint(DialogueEteEndpoints.double_); private final Deserializer double_Deserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -318,9 +315,8 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con _endpointChannelFactory.endpoint(DialogueEteEndpoints.boolean_); private final Deserializer boolean_Deserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -351,9 +347,8 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con _endpointChannelFactory.endpoint(DialogueEteEndpoints.safelong); private final Deserializer safelongDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -383,9 +378,8 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con private final EndpointChannel ridChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.rid); private final Deserializer ridDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -416,9 +410,8 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con _endpointChannelFactory.endpoint(DialogueEteEndpoints.bearertoken); private final Deserializer bearertokenDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -449,9 +442,8 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalString); private final Deserializer> optionalStringDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.>builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker>() {}) + .deserializer(ExceptionDeserializerArgs.>builder() + .returnType(new TypeMarker>() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -482,9 +474,8 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalEmpty); private final Deserializer> optionalEmptyDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.>builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker>() {}) + .deserializer(ExceptionDeserializerArgs.>builder() + .returnType(new TypeMarker>() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -515,9 +506,8 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con _endpointChannelFactory.endpoint(DialogueEteEndpoints.datetime); private final Deserializer datetimeDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -549,9 +539,8 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con private final EndpointChannel pathChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.path); private final Deserializer pathDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -582,9 +571,8 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con _endpointChannelFactory.endpoint(DialogueEteEndpoints.externalLongPath); private final Deserializer externalLongPathDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -615,9 +603,8 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalExternalLongQuery); private final Deserializer> optionalExternalLongQueryDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.>builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker>() {}) + .deserializer(ExceptionDeserializerArgs.>builder() + .returnType(new TypeMarker>() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -651,9 +638,8 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con _endpointChannelFactory.endpoint(DialogueEteEndpoints.notNullBody); private final Deserializer notNullBodyDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -684,9 +670,8 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con _endpointChannelFactory.endpoint(DialogueEteEndpoints.aliasOne); private final Deserializer aliasOneDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -717,9 +702,8 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalAliasOne); private final Deserializer optionalAliasOneDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -750,9 +734,8 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con _endpointChannelFactory.endpoint(DialogueEteEndpoints.aliasTwo); private final Deserializer aliasTwoDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -789,9 +772,9 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con private final Deserializer notNullBodyExternalImportDeserializer = _runtime.bodySerDe() .deserializer( - DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success( + ExceptionDeserializerArgs + .builder() + .returnType( new TypeMarker< allexamples.com.palantir.product.StringAliasExample>() {}) .exception( @@ -844,10 +827,9 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con private final Deserializer> optionalBodyExternalImportDeserializer = _runtime.bodySerDe() .deserializer( - DeserializerArgs + ExceptionDeserializerArgs .>builder() - .baseType(new TypeMarker<>() {}) - .success( + .returnType( new TypeMarker< Optional< allexamples.com.palantir.product @@ -897,10 +879,9 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con private final Deserializer> optionalQueryExternalImportDeserializer = _runtime.bodySerDe() .deserializer( - DeserializerArgs + ExceptionDeserializerArgs .>builder() - .baseType(new TypeMarker<>() {}) - .success( + .returnType( new TypeMarker< Optional< allexamples.com.palantir.product @@ -948,9 +929,8 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con _endpointChannelFactory.endpoint(DialogueEteEndpoints.noReturn); private final Deserializer noReturnDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -981,9 +961,8 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con _endpointChannelFactory.endpoint(DialogueEteEndpoints.enumQuery); private final Deserializer enumQueryDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -1014,9 +993,8 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con _endpointChannelFactory.endpoint(DialogueEteEndpoints.enumListQuery); private final Deserializer> enumListQueryDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.>builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker>() {}) + .deserializer(ExceptionDeserializerArgs.>builder() + .returnType(new TypeMarker>() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -1047,9 +1025,8 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalEnumQuery); private final Deserializer> optionalEnumQueryDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.>builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker>() {}) + .deserializer(ExceptionDeserializerArgs.>builder() + .returnType(new TypeMarker>() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -1080,9 +1057,8 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con _endpointChannelFactory.endpoint(DialogueEteEndpoints.enumHeader); private final Deserializer enumHeaderDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -1113,9 +1089,8 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con _endpointChannelFactory.endpoint(DialogueEteEndpoints.jsonErrorsHeader); private final Deserializer jsonErrorsHeaderDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -1146,9 +1121,8 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con _endpointChannelFactory.endpoint(DialogueEteEndpoints.errorParameterSerialization); private final Deserializer errorParameterSerializationDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -1179,9 +1153,8 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con _endpointChannelFactory.endpoint(DialogueEteEndpoints.aliasLongEndpoint); private final Deserializer> aliasLongEndpointDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.>builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker>() {}) + .deserializer(ExceptionDeserializerArgs.>builder() + .returnType(new TypeMarker>() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -1212,9 +1185,8 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con _endpointChannelFactory.endpoint(DialogueEteEndpoints.complexQueryParameters); private final Deserializer complexQueryParametersDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -1248,9 +1220,8 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con _endpointChannelFactory.endpoint(DialogueEteEndpoints.receiveListOfOptionals); private final Deserializer receiveListOfOptionalsDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -1284,9 +1255,8 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con _endpointChannelFactory.endpoint(DialogueEteEndpoints.receiveSetOfOptionals); private final Deserializer receiveSetOfOptionalsDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, @@ -1320,9 +1290,8 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con _endpointChannelFactory.endpoint(DialogueEteEndpoints.receiveListOfStrings); private final Deserializer receiveListOfStringsDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, diff --git a/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceAsync.java b/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceAsync.java index a7bf63f85..f3e47a75f 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceAsync.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceAsync.java @@ -5,12 +5,12 @@ import com.palantir.dialogue.Channel; import com.palantir.dialogue.ConjureRuntime; import com.palantir.dialogue.Deserializer; -import com.palantir.dialogue.DeserializerArgs; import com.palantir.dialogue.DialogueService; import com.palantir.dialogue.DialogueServiceFactory; import com.palantir.dialogue.Endpoint; import com.palantir.dialogue.EndpointChannel; import com.palantir.dialogue.EndpointChannelFactory; +import com.palantir.dialogue.ExceptionDeserializerArgs; import com.palantir.dialogue.PlainSerDe; import com.palantir.dialogue.Request; import com.palantir.dialogue.TypeMarker; @@ -36,9 +36,8 @@ static CookieServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Con _endpointChannelFactory.endpoint(DialogueCookieEndpoints.eatCookies); private final Deserializer eatCookiesDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .build()); @Override diff --git a/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceBlocking.java b/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceBlocking.java index 50dd62b3a..738073ce9 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceBlocking.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceBlocking.java @@ -4,12 +4,12 @@ import com.palantir.dialogue.Channel; import com.palantir.dialogue.ConjureRuntime; import com.palantir.dialogue.Deserializer; -import com.palantir.dialogue.DeserializerArgs; import com.palantir.dialogue.DialogueService; import com.palantir.dialogue.DialogueServiceFactory; import com.palantir.dialogue.Endpoint; import com.palantir.dialogue.EndpointChannel; import com.palantir.dialogue.EndpointChannelFactory; +import com.palantir.dialogue.ExceptionDeserializerArgs; import com.palantir.dialogue.PlainSerDe; import com.palantir.dialogue.Request; import com.palantir.dialogue.TypeMarker; @@ -35,9 +35,8 @@ static CookieServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, _endpointChannelFactory.endpoint(DialogueCookieEndpoints.eatCookies); private final Deserializer eatCookiesDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) + .deserializer(ExceptionDeserializerArgs.builder() + .returnType(new TypeMarker() {}) .build()); @Override diff --git a/versions.lock b/versions.lock index 5b7a9e5b2..cd8a2450d 100644 --- a/versions.lock +++ b/versions.lock @@ -72,15 +72,15 @@ com.palantir.dialogue:dialogue-apache-hc5-client:6.7.0 (2 constraints: 1a2974b6) com.palantir.dialogue:dialogue-blocking-channels:6.7.0 (2 constraints: 79232973) -com.palantir.dialogue:dialogue-clients:6.7.0 (1 constraints: b40a3dc0) +com.palantir.dialogue:dialogue-clients:6.7.0 (1 constraints: ce07ab7d) com.palantir.dialogue:dialogue-core:6.7.0 (3 constraints: ea3c6541) com.palantir.dialogue:dialogue-futures:6.7.0 (3 constraints: 3e33a938) -com.palantir.dialogue:dialogue-serde:6.7.0 (3 constraints: cd337445) +com.palantir.dialogue:dialogue-serde:6.7.0 (3 constraints: e73072b5) -com.palantir.dialogue:dialogue-target:6.7.0 (7 constraints: 767da404) +com.palantir.dialogue:dialogue-target:6.7.0 (7 constraints: 907a6316) com.palantir.goethe:goethe:0.16.0 (1 constraints: 3905353b) diff --git a/versions.props b/versions.props index 54adb668c..ccb12b90b 100644 --- a/versions.props +++ b/versions.props @@ -12,7 +12,7 @@ com.palantir.conjure.verification:* = 0.19.0 com.palantir.conjure:* = 4.50.0 com.palantir.deadlines:* = 0.15.0 com.palantir.goethe:* = 0.16.0 -com.palantir.dialogue:* = 6.2.0-18-gda82cd0.dirty +com.palantir.dialogue:* = 6.4.0-7-g74a1e71 com.palantir.human-readable-types:* = 1.7.0 com.palantir.javapoet:javapoet = 0.7.0 com.palantir.ri:resource-identifier = 2.11.0 From 0c802214a1630114c7cf1a552c425dfc32040abb Mon Sep 17 00:00:00 2001 From: Pritham Marupaka Date: Wed, 13 Aug 2025 16:40:10 -0400 Subject: [PATCH 12/26] Add helper method to construct --- conjure-java-client-verifier/build.gradle | 2 + .../com/palantir/product/ConjureErrors.java | 25 +- .../palantir/product/ConjureJavaErrors.java | 5 +- .../product/EmptyPathServiceAsync.java | 60 +- .../product/EmptyPathServiceBlocking.java | 60 +- .../product/EteBinaryServiceAsync.java | 32 + .../product/EteBinaryServiceBlocking.java | 32 + .../com/palantir/product/EteServiceAsync.java | 1018 ++--------------- .../palantir/product/EteServiceBlocking.java | 1018 ++--------------- .../dialogue/test/api/CookieServiceAsync.java | 12 +- .../test/api/CookieServiceBlocking.java | 12 +- .../another/EndpointSpecificErrors.java | 2 +- .../com/palantir/product/ConjureErrors.java | 2 +- .../product/EndpointSpecificErrors.java | 2 +- .../product/EndpointSpecificTwoErrors.java | 2 +- .../com/palantir/product/TestErrors.java | 2 +- .../com/palantir/another/ConjureErrors.java | 5 +- .../another/ConjureJavaOtherErrors.java | 5 +- .../com/palantir/product/ConjureErrors.java | 25 +- .../palantir/product/ConjureJavaErrors.java | 5 +- .../another/EndpointSpecificErrors.java | 2 +- .../com/palantir/product/ConjureErrors.java | 2 +- .../product/EndpointSpecificErrors.java | 2 +- .../product/EndpointSpecificTwoErrors.java | 2 +- .../com/palantir/product/TestErrors.java | 2 +- .../DefaultStaticFactoryMethodGenerator.java | 48 + .../conjure/java/types/ErrorGenerator.java | 2 +- 27 files changed, 399 insertions(+), 1987 deletions(-) diff --git a/conjure-java-client-verifier/build.gradle b/conjure-java-client-verifier/build.gradle index 3bddaa15d..8ecaf0032 100644 --- a/conjure-java-client-verifier/build.gradle +++ b/conjure-java-client-verifier/build.gradle @@ -66,6 +66,7 @@ project('verification-server-api') { api 'com.palantir.dialogue:dialogue-clients' api 'com.palantir.dialogue:dialogue-serde' + implementation 'com.fasterxml.jackson.core:jackson-annotations' implementation 'com.fasterxml.jackson.core:jackson-databind' implementation 'com.google.code.findbugs:jsr305' @@ -76,6 +77,7 @@ project('verification-server-api') { implementation 'com.palantir.safe-logging:preconditions' implementation 'com.palantir.safe-logging:safe-logging' implementation 'com.palantir.tokens:auth-tokens' + implementation 'com.palantir.conjure.java.api:errors' } } diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureErrors.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureErrors.java index 3ab301e33..4407db328 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureErrors.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureErrors.java @@ -367,7 +367,7 @@ public static record InvalidTypeDefinitionParameters( public static final class ConflictingCauseSafeArgSerializableError extends AbstractSerializableError { - @org.jspecify.annotations.Nullable + @Nullable private final Map legacyParameters; @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) @@ -376,8 +376,7 @@ public static final class ConflictingCauseSafeArgSerializableError @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, @JsonProperty("parameters") ConflictingCauseSafeArgParameters parameters, - @JsonProperty("legacyParameters") @org.jspecify.annotations.Nullable - Map legacyParameters) { + @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { super(errorCode, errorName, errorInstanceId, parameters); this.legacyParameters = legacyParameters; } @@ -398,7 +397,7 @@ public SerializableError toSerializableError() { public static final class ConflictingCauseUnsafeArgSerializableError extends AbstractSerializableError { - @org.jspecify.annotations.Nullable + @Nullable private final Map legacyParameters; @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) @@ -407,8 +406,7 @@ public static final class ConflictingCauseUnsafeArgSerializableError @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, @JsonProperty("parameters") ConflictingCauseUnsafeArgParameters parameters, - @JsonProperty("legacyParameters") @org.jspecify.annotations.Nullable - Map legacyParameters) { + @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { super(errorCode, errorName, errorInstanceId, parameters); this.legacyParameters = legacyParameters; } @@ -429,7 +427,7 @@ public SerializableError toSerializableError() { public static final class ErrorWithComplexArgsSerializableError extends AbstractSerializableError { - @org.jspecify.annotations.Nullable + @Nullable private final Map legacyParameters; @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) @@ -438,8 +436,7 @@ public static final class ErrorWithComplexArgsSerializableError @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, @JsonProperty("parameters") ErrorWithComplexArgsParameters parameters, - @JsonProperty("legacyParameters") @org.jspecify.annotations.Nullable - Map legacyParameters) { + @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { super(errorCode, errorName, errorInstanceId, parameters); this.legacyParameters = legacyParameters; } @@ -492,7 +489,7 @@ public SerializableError toSerializableError() { public static final class InvalidServiceDefinitionSerializableError extends AbstractSerializableError { - @org.jspecify.annotations.Nullable + @Nullable private final Map legacyParameters; @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) @@ -501,8 +498,7 @@ public static final class InvalidServiceDefinitionSerializableError @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, @JsonProperty("parameters") InvalidServiceDefinitionParameters parameters, - @JsonProperty("legacyParameters") @org.jspecify.annotations.Nullable - Map legacyParameters) { + @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { super(errorCode, errorName, errorInstanceId, parameters); this.legacyParameters = legacyParameters; } @@ -524,7 +520,7 @@ public SerializableError toSerializableError() { public static final class InvalidTypeDefinitionSerializableError extends AbstractSerializableError { - @org.jspecify.annotations.Nullable + @Nullable private final Map legacyParameters; @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) @@ -533,8 +529,7 @@ public static final class InvalidTypeDefinitionSerializableError @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, @JsonProperty("parameters") InvalidTypeDefinitionParameters parameters, - @JsonProperty("legacyParameters") @org.jspecify.annotations.Nullable - Map legacyParameters) { + @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { super(errorCode, errorName, errorInstanceId, parameters); this.legacyParameters = legacyParameters; } diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureJavaErrors.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureJavaErrors.java index 3e809c7fc..d8774cdf5 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureJavaErrors.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureJavaErrors.java @@ -49,7 +49,7 @@ public static record JavaCompilationFailedParameters() {} public static final class JavaCompilationFailedSerializableError extends AbstractSerializableError { - @org.jspecify.annotations.Nullable + @Nullable private final Map legacyParameters; @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) @@ -58,8 +58,7 @@ public static final class JavaCompilationFailedSerializableError @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, @JsonProperty("parameters") JavaCompilationFailedParameters parameters, - @JsonProperty("legacyParameters") @org.jspecify.annotations.Nullable - Map legacyParameters) { + @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { super(errorCode, errorName, errorInstanceId, parameters); this.legacyParameters = legacyParameters; } diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceAsync.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceAsync.java index a808a8132..db77bb559 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceAsync.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceAsync.java @@ -34,34 +34,38 @@ static EmptyPathServiceAsync of(EndpointChannelFactory _endpointChannelFactory, private final EndpointChannel emptyPathChannel = _endpointChannelFactory.endpoint(DialogueEmptyPathEndpoints.emptyPath); - private final Deserializer emptyPathDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + private final Deserializer emptyPathDeserializer = + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + + private ExceptionDeserializerArgs createExceptionDeserializerArgs(TypeMarker returnType) { + return ExceptionDeserializerArgs.builder() + .returnType(returnType) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build(); + } @Override public ListenableFuture emptyPath() { diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceBlocking.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceBlocking.java index c8d1ef041..203262d5a 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceBlocking.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceBlocking.java @@ -33,34 +33,38 @@ static EmptyPathServiceBlocking of(EndpointChannelFactory _endpointChannelFactor private final EndpointChannel emptyPathChannel = _endpointChannelFactory.endpoint(DialogueEmptyPathEndpoints.emptyPath); - private final Deserializer emptyPathDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + private final Deserializer emptyPathDeserializer = + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + + private ExceptionDeserializerArgs createExceptionDeserializerArgs(TypeMarker returnType) { + return ExceptionDeserializerArgs.builder() + .returnType(returnType) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build(); + } @Override public boolean emptyPath() { diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceAsync.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceAsync.java index c55ed3f47..9aa1cc9cb 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceAsync.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceAsync.java @@ -10,8 +10,10 @@ import com.palantir.dialogue.Endpoint; import com.palantir.dialogue.EndpointChannel; import com.palantir.dialogue.EndpointChannelFactory; +import com.palantir.dialogue.ExceptionDeserializerArgs; import com.palantir.dialogue.PlainSerDe; import com.palantir.dialogue.Request; +import com.palantir.dialogue.TypeMarker; import com.palantir.tokens.auth.AuthHeader; import java.io.InputStream; import java.lang.Override; @@ -73,6 +75,36 @@ static EteBinaryServiceAsync of(EndpointChannelFactory _endpointChannelFactory, private final EndpointChannel getAliasedChannel = _endpointChannelFactory.endpoint(DialogueEteBinaryEndpoints.getAliased); + private ExceptionDeserializerArgs createExceptionDeserializerArgs(TypeMarker returnType) { + return ExceptionDeserializerArgs.builder() + .returnType(returnType) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build(); + } + @Override public ListenableFuture postBinary(AuthHeader authHeader, BinaryRequestBody body) { Request.Builder _request = Request.builder(); diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceBlocking.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceBlocking.java index f8d00aa65..632d94bca 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceBlocking.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceBlocking.java @@ -10,8 +10,10 @@ import com.palantir.dialogue.Endpoint; import com.palantir.dialogue.EndpointChannel; import com.palantir.dialogue.EndpointChannelFactory; +import com.palantir.dialogue.ExceptionDeserializerArgs; import com.palantir.dialogue.PlainSerDe; import com.palantir.dialogue.Request; +import com.palantir.dialogue.TypeMarker; import com.palantir.tokens.auth.AuthHeader; import java.io.InputStream; import java.lang.Override; @@ -76,6 +78,36 @@ static EteBinaryServiceBlocking of(EndpointChannelFactory _endpointChannelFactor private final EndpointChannel getAliasedChannel = _endpointChannelFactory.endpoint(DialogueEteBinaryEndpoints.getAliased); + private ExceptionDeserializerArgs createExceptionDeserializerArgs(TypeMarker returnType) { + return ExceptionDeserializerArgs.builder() + .returnType(returnType) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build(); + } + @Override public InputStream postBinary(AuthHeader authHeader, BinaryRequestBody body) { Request.Builder _request = Request.builder(); diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceAsync.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceAsync.java index 3b1fb425b..7d1aae227 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceAsync.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceAsync.java @@ -219,418 +219,80 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur private final EndpointChannel stringChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.string); - private final Deserializer stringDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + private final Deserializer stringDeserializer = + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel integerChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.integer); - private final Deserializer integerDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + private final Deserializer integerDeserializer = + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel double_Channel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.double_); - private final Deserializer double_Deserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + private final Deserializer double_Deserializer = + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel boolean_Channel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.boolean_); - private final Deserializer boolean_Deserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + private final Deserializer boolean_Deserializer = + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel safelongChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.safelong); - private final Deserializer safelongDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + private final Deserializer safelongDeserializer = + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel ridChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.rid); private final Deserializer ridDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + .deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel bearertokenChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.bearertoken); private final Deserializer bearertokenDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + .deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel optionalStringChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalString); private final Deserializer> optionalStringDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.>builder() - .returnType(new TypeMarker>() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + .deserializer(createExceptionDeserializerArgs(new TypeMarker>() {})); private final EndpointChannel optionalEmptyChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalEmpty); private final Deserializer> optionalEmptyDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.>builder() - .returnType(new TypeMarker>() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + .deserializer(createExceptionDeserializerArgs(new TypeMarker>() {})); private final EndpointChannel datetimeChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.datetime); private final Deserializer datetimeDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + .deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel binaryChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.binary); private final EndpointChannel pathChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.path); - private final Deserializer pathDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + private final Deserializer pathDeserializer = + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel externalLongPathChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.externalLongPath); - private final Deserializer externalLongPathDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + private final Deserializer externalLongPathDeserializer = + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel optionalExternalLongQueryChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalExternalLongQuery); private final Deserializer> optionalExternalLongQueryDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.>builder() - .returnType(new TypeMarker>() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + .deserializer(createExceptionDeserializerArgs(new TypeMarker>() {})); private final Serializer notNullBodySerializer = _runtime.bodySerDe().serializer(new TypeMarker() {}); @@ -639,129 +301,25 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur _endpointChannelFactory.endpoint(DialogueEteEndpoints.notNullBody); private final Deserializer notNullBodyDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + .deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel aliasOneChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.aliasOne); private final Deserializer aliasOneDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + .deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel optionalAliasOneChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalAliasOne); private final Deserializer optionalAliasOneDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + .deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel aliasTwoChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.aliasTwo); private final Deserializer aliasTwoDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + .deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final Serializer notNullBodyExternalImportSerializer = _runtime.bodySerDe() @@ -772,50 +330,8 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur private final Deserializer notNullBodyExternalImportDeserializer = _runtime.bodySerDe() - .deserializer( - ExceptionDeserializerArgs - .builder() - .returnType( - new TypeMarker< - allexamples.com.palantir.product.StringAliasExample>() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker< - ConjureErrors - .ConflictingCauseSafeArgSerializableError>() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker< - ConjureErrors - .ConflictingCauseUnsafeArgSerializableError>() {}, - new TypeMarker< - ConjureErrors.ConflictingCauseUnsafeArgException>() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker< - ConjureErrors.ErrorWithComplexArgsSerializableError>() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker< - ConjureErrors - .InvalidServiceDefinitionSerializableError>() {}, - new TypeMarker< - ConjureErrors.InvalidServiceDefinitionException>() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker< - ConjureErrors.InvalidTypeDefinitionSerializableError>() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker< - ConjureJavaErrors - .JavaCompilationFailedSerializableError>() {}, - new TypeMarker< - ConjureJavaErrors.JavaCompilationFailedException>() {}) - .build()); + .deserializer(createExceptionDeserializerArgs( + new TypeMarker() {})); private final Serializer> optionalBodyExternalImportSerializer = _runtime.bodySerDe() @@ -827,392 +343,72 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur private final Deserializer> optionalBodyExternalImportDeserializer = _runtime.bodySerDe() - .deserializer( - ExceptionDeserializerArgs - .>builder() - .returnType( - new TypeMarker< - Optional< - allexamples.com.palantir.product - .StringAliasExample>>() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker< - ConjureErrors - .ConflictingCauseSafeArgSerializableError>() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker< - ConjureErrors - .ConflictingCauseUnsafeArgSerializableError>() {}, - new TypeMarker< - ConjureErrors.ConflictingCauseUnsafeArgException>() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker< - ConjureErrors.ErrorWithComplexArgsSerializableError>() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker< - ConjureErrors - .InvalidServiceDefinitionSerializableError>() {}, - new TypeMarker< - ConjureErrors.InvalidServiceDefinitionException>() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker< - ConjureErrors.InvalidTypeDefinitionSerializableError>() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker< - ConjureJavaErrors - .JavaCompilationFailedSerializableError>() {}, - new TypeMarker< - ConjureJavaErrors.JavaCompilationFailedException>() {}) - .build()); + .deserializer(createExceptionDeserializerArgs( + new TypeMarker< + Optional>() {})); private final EndpointChannel optionalQueryExternalImportChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalQueryExternalImport); private final Deserializer> optionalQueryExternalImportDeserializer = _runtime.bodySerDe() - .deserializer( - ExceptionDeserializerArgs - .>builder() - .returnType( - new TypeMarker< - Optional< - allexamples.com.palantir.product - .StringAliasExample>>() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker< - ConjureErrors - .ConflictingCauseSafeArgSerializableError>() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker< - ConjureErrors - .ConflictingCauseUnsafeArgSerializableError>() {}, - new TypeMarker< - ConjureErrors.ConflictingCauseUnsafeArgException>() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker< - ConjureErrors.ErrorWithComplexArgsSerializableError>() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker< - ConjureErrors - .InvalidServiceDefinitionSerializableError>() {}, - new TypeMarker< - ConjureErrors.InvalidServiceDefinitionException>() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker< - ConjureErrors.InvalidTypeDefinitionSerializableError>() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker< - ConjureJavaErrors - .JavaCompilationFailedSerializableError>() {}, - new TypeMarker< - ConjureJavaErrors.JavaCompilationFailedException>() {}) - .build()); + .deserializer(createExceptionDeserializerArgs( + new TypeMarker< + Optional>() {})); private final EndpointChannel noReturnChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.noReturn); - private final Deserializer noReturnDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + private final Deserializer noReturnDeserializer = + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel enumQueryChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.enumQuery); - private final Deserializer enumQueryDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + private final Deserializer enumQueryDeserializer = + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel enumListQueryChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.enumListQuery); private final Deserializer> enumListQueryDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.>builder() - .returnType(new TypeMarker>() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + .deserializer(createExceptionDeserializerArgs(new TypeMarker>() {})); private final EndpointChannel optionalEnumQueryChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalEnumQuery); private final Deserializer> optionalEnumQueryDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.>builder() - .returnType(new TypeMarker>() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + .deserializer(createExceptionDeserializerArgs(new TypeMarker>() {})); private final EndpointChannel enumHeaderChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.enumHeader); - private final Deserializer enumHeaderDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + private final Deserializer enumHeaderDeserializer = + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel jsonErrorsHeaderChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.jsonErrorsHeader); - private final Deserializer jsonErrorsHeaderDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + private final Deserializer jsonErrorsHeaderDeserializer = + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel errorParameterSerializationChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.errorParameterSerialization); - private final Deserializer errorParameterSerializationDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + private final Deserializer errorParameterSerializationDeserializer = + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel aliasLongEndpointChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.aliasLongEndpoint); private final Deserializer> aliasLongEndpointDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.>builder() - .returnType(new TypeMarker>() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + .deserializer(createExceptionDeserializerArgs(new TypeMarker>() {})); private final EndpointChannel complexQueryParametersChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.complexQueryParameters); - private final Deserializer complexQueryParametersDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + private final Deserializer complexQueryParametersDeserializer = + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final Serializer>> receiveListOfOptionalsSerializer = _runtime.bodySerDe().serializer(new TypeMarker>>() {}); @@ -1220,34 +416,8 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur private final EndpointChannel receiveListOfOptionalsChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.receiveListOfOptionals); - private final Deserializer receiveListOfOptionalsDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + private final Deserializer receiveListOfOptionalsDeserializer = + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final Serializer>> receiveSetOfOptionalsSerializer = _runtime.bodySerDe().serializer(new TypeMarker>>() {}); @@ -1255,34 +425,8 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur private final EndpointChannel receiveSetOfOptionalsChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.receiveSetOfOptionals); - private final Deserializer receiveSetOfOptionalsDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + private final Deserializer receiveSetOfOptionalsDeserializer = + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final Serializer> receiveListOfStringsSerializer = _runtime.bodySerDe().serializer(new TypeMarker>() {}); @@ -1290,34 +434,38 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur private final EndpointChannel receiveListOfStringsChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.receiveListOfStrings); - private final Deserializer receiveListOfStringsDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + private final Deserializer receiveListOfStringsDeserializer = + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + + private ExceptionDeserializerArgs createExceptionDeserializerArgs(TypeMarker returnType) { + return ExceptionDeserializerArgs.builder() + .returnType(returnType) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build(); + } @Override public ListenableFuture string(AuthHeader authHeader) { diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceBlocking.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceBlocking.java index 979d55d1d..6790d2d84 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceBlocking.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceBlocking.java @@ -218,418 +218,80 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con private final EndpointChannel stringChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.string); - private final Deserializer stringDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + private final Deserializer stringDeserializer = + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel integerChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.integer); - private final Deserializer integerDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + private final Deserializer integerDeserializer = + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel double_Channel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.double_); - private final Deserializer double_Deserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + private final Deserializer double_Deserializer = + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel boolean_Channel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.boolean_); - private final Deserializer boolean_Deserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + private final Deserializer boolean_Deserializer = + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel safelongChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.safelong); - private final Deserializer safelongDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + private final Deserializer safelongDeserializer = + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel ridChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.rid); private final Deserializer ridDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + .deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel bearertokenChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.bearertoken); private final Deserializer bearertokenDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + .deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel optionalStringChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalString); private final Deserializer> optionalStringDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.>builder() - .returnType(new TypeMarker>() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + .deserializer(createExceptionDeserializerArgs(new TypeMarker>() {})); private final EndpointChannel optionalEmptyChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalEmpty); private final Deserializer> optionalEmptyDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.>builder() - .returnType(new TypeMarker>() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + .deserializer(createExceptionDeserializerArgs(new TypeMarker>() {})); private final EndpointChannel datetimeChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.datetime); private final Deserializer datetimeDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + .deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel binaryChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.binary); private final EndpointChannel pathChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.path); - private final Deserializer pathDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + private final Deserializer pathDeserializer = + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel externalLongPathChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.externalLongPath); - private final Deserializer externalLongPathDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + private final Deserializer externalLongPathDeserializer = + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel optionalExternalLongQueryChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalExternalLongQuery); private final Deserializer> optionalExternalLongQueryDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.>builder() - .returnType(new TypeMarker>() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + .deserializer(createExceptionDeserializerArgs(new TypeMarker>() {})); private final Serializer notNullBodySerializer = _runtime.bodySerDe().serializer(new TypeMarker() {}); @@ -638,129 +300,25 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con _endpointChannelFactory.endpoint(DialogueEteEndpoints.notNullBody); private final Deserializer notNullBodyDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + .deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel aliasOneChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.aliasOne); private final Deserializer aliasOneDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + .deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel optionalAliasOneChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalAliasOne); private final Deserializer optionalAliasOneDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + .deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel aliasTwoChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.aliasTwo); private final Deserializer aliasTwoDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + .deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final Serializer notNullBodyExternalImportSerializer = _runtime.bodySerDe() @@ -771,50 +329,8 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con private final Deserializer notNullBodyExternalImportDeserializer = _runtime.bodySerDe() - .deserializer( - ExceptionDeserializerArgs - .builder() - .returnType( - new TypeMarker< - allexamples.com.palantir.product.StringAliasExample>() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker< - ConjureErrors - .ConflictingCauseSafeArgSerializableError>() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker< - ConjureErrors - .ConflictingCauseUnsafeArgSerializableError>() {}, - new TypeMarker< - ConjureErrors.ConflictingCauseUnsafeArgException>() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker< - ConjureErrors.ErrorWithComplexArgsSerializableError>() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker< - ConjureErrors - .InvalidServiceDefinitionSerializableError>() {}, - new TypeMarker< - ConjureErrors.InvalidServiceDefinitionException>() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker< - ConjureErrors.InvalidTypeDefinitionSerializableError>() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker< - ConjureJavaErrors - .JavaCompilationFailedSerializableError>() {}, - new TypeMarker< - ConjureJavaErrors.JavaCompilationFailedException>() {}) - .build()); + .deserializer(createExceptionDeserializerArgs( + new TypeMarker() {})); private final Serializer> optionalBodyExternalImportSerializer = _runtime.bodySerDe() @@ -826,392 +342,72 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con private final Deserializer> optionalBodyExternalImportDeserializer = _runtime.bodySerDe() - .deserializer( - ExceptionDeserializerArgs - .>builder() - .returnType( - new TypeMarker< - Optional< - allexamples.com.palantir.product - .StringAliasExample>>() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker< - ConjureErrors - .ConflictingCauseSafeArgSerializableError>() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker< - ConjureErrors - .ConflictingCauseUnsafeArgSerializableError>() {}, - new TypeMarker< - ConjureErrors.ConflictingCauseUnsafeArgException>() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker< - ConjureErrors.ErrorWithComplexArgsSerializableError>() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker< - ConjureErrors - .InvalidServiceDefinitionSerializableError>() {}, - new TypeMarker< - ConjureErrors.InvalidServiceDefinitionException>() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker< - ConjureErrors.InvalidTypeDefinitionSerializableError>() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker< - ConjureJavaErrors - .JavaCompilationFailedSerializableError>() {}, - new TypeMarker< - ConjureJavaErrors.JavaCompilationFailedException>() {}) - .build()); + .deserializer(createExceptionDeserializerArgs( + new TypeMarker< + Optional>() {})); private final EndpointChannel optionalQueryExternalImportChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalQueryExternalImport); private final Deserializer> optionalQueryExternalImportDeserializer = _runtime.bodySerDe() - .deserializer( - ExceptionDeserializerArgs - .>builder() - .returnType( - new TypeMarker< - Optional< - allexamples.com.palantir.product - .StringAliasExample>>() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker< - ConjureErrors - .ConflictingCauseSafeArgSerializableError>() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker< - ConjureErrors - .ConflictingCauseUnsafeArgSerializableError>() {}, - new TypeMarker< - ConjureErrors.ConflictingCauseUnsafeArgException>() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker< - ConjureErrors.ErrorWithComplexArgsSerializableError>() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker< - ConjureErrors - .InvalidServiceDefinitionSerializableError>() {}, - new TypeMarker< - ConjureErrors.InvalidServiceDefinitionException>() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker< - ConjureErrors.InvalidTypeDefinitionSerializableError>() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker< - ConjureJavaErrors - .JavaCompilationFailedSerializableError>() {}, - new TypeMarker< - ConjureJavaErrors.JavaCompilationFailedException>() {}) - .build()); + .deserializer(createExceptionDeserializerArgs( + new TypeMarker< + Optional>() {})); private final EndpointChannel noReturnChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.noReturn); - private final Deserializer noReturnDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + private final Deserializer noReturnDeserializer = + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel enumQueryChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.enumQuery); - private final Deserializer enumQueryDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + private final Deserializer enumQueryDeserializer = + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel enumListQueryChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.enumListQuery); private final Deserializer> enumListQueryDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.>builder() - .returnType(new TypeMarker>() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + .deserializer(createExceptionDeserializerArgs(new TypeMarker>() {})); private final EndpointChannel optionalEnumQueryChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalEnumQuery); private final Deserializer> optionalEnumQueryDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.>builder() - .returnType(new TypeMarker>() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + .deserializer(createExceptionDeserializerArgs(new TypeMarker>() {})); private final EndpointChannel enumHeaderChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.enumHeader); - private final Deserializer enumHeaderDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + private final Deserializer enumHeaderDeserializer = + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel jsonErrorsHeaderChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.jsonErrorsHeader); - private final Deserializer jsonErrorsHeaderDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + private final Deserializer jsonErrorsHeaderDeserializer = + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel errorParameterSerializationChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.errorParameterSerialization); - private final Deserializer errorParameterSerializationDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + private final Deserializer errorParameterSerializationDeserializer = + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel aliasLongEndpointChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.aliasLongEndpoint); private final Deserializer> aliasLongEndpointDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.>builder() - .returnType(new TypeMarker>() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + .deserializer(createExceptionDeserializerArgs(new TypeMarker>() {})); private final EndpointChannel complexQueryParametersChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.complexQueryParameters); - private final Deserializer complexQueryParametersDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + private final Deserializer complexQueryParametersDeserializer = + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final Serializer>> receiveListOfOptionalsSerializer = _runtime.bodySerDe().serializer(new TypeMarker>>() {}); @@ -1219,34 +415,8 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con private final EndpointChannel receiveListOfOptionalsChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.receiveListOfOptionals); - private final Deserializer receiveListOfOptionalsDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + private final Deserializer receiveListOfOptionalsDeserializer = + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final Serializer>> receiveSetOfOptionalsSerializer = _runtime.bodySerDe().serializer(new TypeMarker>>() {}); @@ -1254,34 +424,8 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con private final EndpointChannel receiveSetOfOptionalsChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.receiveSetOfOptionals); - private final Deserializer receiveSetOfOptionalsDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + private final Deserializer receiveSetOfOptionalsDeserializer = + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final Serializer> receiveListOfStringsSerializer = _runtime.bodySerDe().serializer(new TypeMarker>() {}); @@ -1289,34 +433,38 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con private final EndpointChannel receiveListOfStringsChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.receiveListOfStrings); - private final Deserializer receiveListOfStringsDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build()); + private final Deserializer receiveListOfStringsDeserializer = + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + + private ExceptionDeserializerArgs createExceptionDeserializerArgs(TypeMarker returnType) { + return ExceptionDeserializerArgs.builder() + .returnType(returnType) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build(); + } @Override public String string(AuthHeader authHeader) { diff --git a/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceAsync.java b/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceAsync.java index f3e47a75f..346cefe41 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceAsync.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceAsync.java @@ -35,10 +35,14 @@ static CookieServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Con private final EndpointChannel eatCookiesChannel = _endpointChannelFactory.endpoint(DialogueCookieEndpoints.eatCookies); - private final Deserializer eatCookiesDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .build()); + private final Deserializer eatCookiesDeserializer = + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + + private ExceptionDeserializerArgs createExceptionDeserializerArgs(TypeMarker returnType) { + return ExceptionDeserializerArgs.builder() + .returnType(returnType) + .build(); + } @Override public ListenableFuture eatCookies(BearerToken token) { diff --git a/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceBlocking.java b/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceBlocking.java index 738073ce9..ad73ae830 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceBlocking.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceBlocking.java @@ -34,10 +34,14 @@ static CookieServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, private final EndpointChannel eatCookiesChannel = _endpointChannelFactory.endpoint(DialogueCookieEndpoints.eatCookies); - private final Deserializer eatCookiesDeserializer = _runtime.bodySerDe() - .deserializer(ExceptionDeserializerArgs.builder() - .returnType(new TypeMarker() {}) - .build()); + private final Deserializer eatCookiesDeserializer = + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + + private ExceptionDeserializerArgs createExceptionDeserializerArgs(TypeMarker returnType) { + return ExceptionDeserializerArgs.builder() + .returnType(returnType) + .build(); + } @Override public void eatCookies(BearerToken token) { diff --git a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/another/EndpointSpecificErrors.java b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/another/EndpointSpecificErrors.java index 6ebc7dc34..7250238d2 100644 --- a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/another/EndpointSpecificErrors.java +++ b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/another/EndpointSpecificErrors.java @@ -9,8 +9,8 @@ import com.palantir.logsafe.Preconditions; import com.palantir.logsafe.Safe; import java.util.Map; +import javax.annotation.Nullable; import javax.annotation.processing.Generated; -import org.jspecify.annotations.Nullable; @Generated("com.palantir.conjure.java.types.ErrorGenerator") public final class EndpointSpecificErrors { diff --git a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ConjureErrors.java b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ConjureErrors.java index d34a7fcc8..93b10f640 100644 --- a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ConjureErrors.java +++ b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ConjureErrors.java @@ -10,8 +10,8 @@ import com.palantir.logsafe.Safe; import java.util.Map; import java.util.Objects; +import javax.annotation.Nullable; import javax.annotation.processing.Generated; -import org.jspecify.annotations.Nullable; @Generated("com.palantir.conjure.java.types.ErrorGenerator") public final class ConjureErrors { diff --git a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/EndpointSpecificErrors.java b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/EndpointSpecificErrors.java index f7e41fb0c..e1dd3226e 100644 --- a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/EndpointSpecificErrors.java +++ b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/EndpointSpecificErrors.java @@ -11,8 +11,8 @@ import com.palantir.logsafe.Unsafe; import java.util.Map; import java.util.Objects; +import javax.annotation.Nullable; import javax.annotation.processing.Generated; -import org.jspecify.annotations.Nullable; @Generated("com.palantir.conjure.java.types.ErrorGenerator") public final class EndpointSpecificErrors { diff --git a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/EndpointSpecificTwoErrors.java b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/EndpointSpecificTwoErrors.java index c3bf8ad03..1679b6e8d 100644 --- a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/EndpointSpecificTwoErrors.java +++ b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/EndpointSpecificTwoErrors.java @@ -9,8 +9,8 @@ import com.palantir.logsafe.Preconditions; import com.palantir.logsafe.Safe; import java.util.Map; +import javax.annotation.Nullable; import javax.annotation.processing.Generated; -import org.jspecify.annotations.Nullable; @Generated("com.palantir.conjure.java.types.ErrorGenerator") public final class EndpointSpecificTwoErrors { diff --git a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/TestErrors.java b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/TestErrors.java index bfe68c7bf..ff98891f0 100644 --- a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/TestErrors.java +++ b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/TestErrors.java @@ -11,8 +11,8 @@ import com.palantir.logsafe.Unsafe; import java.util.Map; import java.util.Objects; +import javax.annotation.Nullable; import javax.annotation.processing.Generated; -import org.jspecify.annotations.Nullable; @Generated("com.palantir.conjure.java.types.ErrorGenerator") public final class TestErrors { diff --git a/conjure-java-core/src/integrationInput/java/errors/com/palantir/another/ConjureErrors.java b/conjure-java-core/src/integrationInput/java/errors/com/palantir/another/ConjureErrors.java index 9be0b0828..29040e281 100644 --- a/conjure-java-core/src/integrationInput/java/errors/com/palantir/another/ConjureErrors.java +++ b/conjure-java-core/src/integrationInput/java/errors/com/palantir/another/ConjureErrors.java @@ -52,7 +52,7 @@ public static record DifferentPackageErrParameters() {} public static final class DifferentPackageErrSerializableError extends AbstractSerializableError { - @org.jspecify.annotations.Nullable + @Nullable private final Map legacyParameters; @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) @@ -61,8 +61,7 @@ public static final class DifferentPackageErrSerializableError @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, @JsonProperty("parameters") DifferentPackageErrParameters parameters, - @JsonProperty("legacyParameters") @org.jspecify.annotations.Nullable - Map legacyParameters) { + @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { super(errorCode, errorName, errorInstanceId, parameters); this.legacyParameters = legacyParameters; } diff --git a/conjure-java-core/src/integrationInput/java/errors/com/palantir/another/ConjureJavaOtherErrors.java b/conjure-java-core/src/integrationInput/java/errors/com/palantir/another/ConjureJavaOtherErrors.java index 223104000..992d77a23 100644 --- a/conjure-java-core/src/integrationInput/java/errors/com/palantir/another/ConjureJavaOtherErrors.java +++ b/conjure-java-core/src/integrationInput/java/errors/com/palantir/another/ConjureJavaOtherErrors.java @@ -52,7 +52,7 @@ public static record JavaCompilationFailedParameters() {} public static final class JavaCompilationFailedSerializableError extends AbstractSerializableError { - @org.jspecify.annotations.Nullable + @Nullable private final Map legacyParameters; @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) @@ -61,8 +61,7 @@ public static final class JavaCompilationFailedSerializableError @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, @JsonProperty("parameters") JavaCompilationFailedParameters parameters, - @JsonProperty("legacyParameters") @org.jspecify.annotations.Nullable - Map legacyParameters) { + @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { super(errorCode, errorName, errorInstanceId, parameters); this.legacyParameters = legacyParameters; } diff --git a/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureErrors.java b/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureErrors.java index 8c5e24da0..339c74287 100644 --- a/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureErrors.java +++ b/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureErrors.java @@ -374,7 +374,7 @@ public static record InvalidTypeDefinitionParameters( public static final class ConflictingCauseSafeArgSerializableError extends AbstractSerializableError { - @org.jspecify.annotations.Nullable + @Nullable private final Map legacyParameters; @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) @@ -383,8 +383,7 @@ public static final class ConflictingCauseSafeArgSerializableError @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, @JsonProperty("parameters") ConflictingCauseSafeArgParameters parameters, - @JsonProperty("legacyParameters") @org.jspecify.annotations.Nullable - Map legacyParameters) { + @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { super(errorCode, errorName, errorInstanceId, parameters); this.legacyParameters = legacyParameters; } @@ -405,7 +404,7 @@ public SerializableError toSerializableError() { public static final class ConflictingCauseUnsafeArgSerializableError extends AbstractSerializableError { - @org.jspecify.annotations.Nullable + @Nullable private final Map legacyParameters; @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) @@ -414,8 +413,7 @@ public static final class ConflictingCauseUnsafeArgSerializableError @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, @JsonProperty("parameters") ConflictingCauseUnsafeArgParameters parameters, - @JsonProperty("legacyParameters") @org.jspecify.annotations.Nullable - Map legacyParameters) { + @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { super(errorCode, errorName, errorInstanceId, parameters); this.legacyParameters = legacyParameters; } @@ -436,7 +434,7 @@ public SerializableError toSerializableError() { public static final class ErrorWithComplexArgsSerializableError extends AbstractSerializableError { - @org.jspecify.annotations.Nullable + @Nullable private final Map legacyParameters; @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) @@ -445,8 +443,7 @@ public static final class ErrorWithComplexArgsSerializableError @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, @JsonProperty("parameters") ErrorWithComplexArgsParameters parameters, - @JsonProperty("legacyParameters") @org.jspecify.annotations.Nullable - Map legacyParameters) { + @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { super(errorCode, errorName, errorInstanceId, parameters); this.legacyParameters = legacyParameters; } @@ -499,7 +496,7 @@ public SerializableError toSerializableError() { public static final class InvalidServiceDefinitionSerializableError extends AbstractSerializableError { - @org.jspecify.annotations.Nullable + @Nullable private final Map legacyParameters; @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) @@ -508,8 +505,7 @@ public static final class InvalidServiceDefinitionSerializableError @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, @JsonProperty("parameters") InvalidServiceDefinitionParameters parameters, - @JsonProperty("legacyParameters") @org.jspecify.annotations.Nullable - Map legacyParameters) { + @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { super(errorCode, errorName, errorInstanceId, parameters); this.legacyParameters = legacyParameters; } @@ -531,7 +527,7 @@ public SerializableError toSerializableError() { public static final class InvalidTypeDefinitionSerializableError extends AbstractSerializableError { - @org.jspecify.annotations.Nullable + @Nullable private final Map legacyParameters; @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) @@ -540,8 +536,7 @@ public static final class InvalidTypeDefinitionSerializableError @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, @JsonProperty("parameters") InvalidTypeDefinitionParameters parameters, - @JsonProperty("legacyParameters") @org.jspecify.annotations.Nullable - Map legacyParameters) { + @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { super(errorCode, errorName, errorInstanceId, parameters); this.legacyParameters = legacyParameters; } diff --git a/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureJavaErrors.java b/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureJavaErrors.java index 655b73304..bbff42054 100644 --- a/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureJavaErrors.java +++ b/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureJavaErrors.java @@ -52,7 +52,7 @@ public static record JavaCompilationFailedParameters() {} public static final class JavaCompilationFailedSerializableError extends AbstractSerializableError { - @org.jspecify.annotations.Nullable + @Nullable private final Map legacyParameters; @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) @@ -61,8 +61,7 @@ public static final class JavaCompilationFailedSerializableError @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, @JsonProperty("parameters") JavaCompilationFailedParameters parameters, - @JsonProperty("legacyParameters") @org.jspecify.annotations.Nullable - Map legacyParameters) { + @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { super(errorCode, errorName, errorInstanceId, parameters); this.legacyParameters = legacyParameters; } diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/another/EndpointSpecificErrors.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/another/EndpointSpecificErrors.java index 61d594225..1716b4f30 100644 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/another/EndpointSpecificErrors.java +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/another/EndpointSpecificErrors.java @@ -9,8 +9,8 @@ import com.palantir.logsafe.Preconditions; import com.palantir.logsafe.Safe; import java.util.Map; +import javax.annotation.Nullable; import javax.annotation.processing.Generated; -import org.jspecify.annotations.Nullable; @Generated("com.palantir.conjure.java.types.ErrorGenerator") public final class EndpointSpecificErrors { diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ConjureErrors.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ConjureErrors.java index 250f0e745..b48168995 100644 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ConjureErrors.java +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ConjureErrors.java @@ -10,8 +10,8 @@ import com.palantir.logsafe.Safe; import java.util.Map; import java.util.Objects; +import javax.annotation.Nullable; import javax.annotation.processing.Generated; -import org.jspecify.annotations.Nullable; @Generated("com.palantir.conjure.java.types.ErrorGenerator") public final class ConjureErrors { diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EndpointSpecificErrors.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EndpointSpecificErrors.java index fc4e5cf20..7754a042b 100644 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EndpointSpecificErrors.java +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EndpointSpecificErrors.java @@ -11,8 +11,8 @@ import com.palantir.logsafe.Unsafe; import java.util.Map; import java.util.Objects; +import javax.annotation.Nullable; import javax.annotation.processing.Generated; -import org.jspecify.annotations.Nullable; @Generated("com.palantir.conjure.java.types.ErrorGenerator") public final class EndpointSpecificErrors { diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EndpointSpecificTwoErrors.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EndpointSpecificTwoErrors.java index 4723d7b54..66fa6ace4 100644 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EndpointSpecificTwoErrors.java +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EndpointSpecificTwoErrors.java @@ -9,8 +9,8 @@ import com.palantir.logsafe.Preconditions; import com.palantir.logsafe.Safe; import java.util.Map; +import javax.annotation.Nullable; import javax.annotation.processing.Generated; -import org.jspecify.annotations.Nullable; @Generated("com.palantir.conjure.java.types.ErrorGenerator") public final class EndpointSpecificTwoErrors { diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/TestErrors.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/TestErrors.java index 6d55990d9..ed010d381 100644 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/TestErrors.java +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/TestErrors.java @@ -11,8 +11,8 @@ import com.palantir.logsafe.Unsafe; import java.util.Map; import java.util.Objects; +import javax.annotation.Nullable; import javax.annotation.processing.Generated; -import org.jspecify.annotations.Nullable; @Generated("com.palantir.conjure.java.types.ErrorGenerator") public final class TestErrors { diff --git a/conjure-java-core/src/main/java/com/palantir/conjure/java/services/dialogue/DefaultStaticFactoryMethodGenerator.java b/conjure-java-core/src/main/java/com/palantir/conjure/java/services/dialogue/DefaultStaticFactoryMethodGenerator.java index da48f4bb5..14ea52f15 100644 --- a/conjure-java-core/src/main/java/com/palantir/conjure/java/services/dialogue/DefaultStaticFactoryMethodGenerator.java +++ b/conjure-java-core/src/main/java/com/palantir/conjure/java/services/dialogue/DefaultStaticFactoryMethodGenerator.java @@ -18,7 +18,9 @@ import com.google.common.collect.ImmutableMap; import com.palantir.conjure.java.Options; import com.palantir.conjure.java.services.Auth; +import com.palantir.conjure.java.util.ErrorGenerationUtils; import com.palantir.conjure.java.util.ErrorGenerationUtils.PackageToErrorDefinitionsMapping; +import com.palantir.conjure.java.util.Packages; import com.palantir.conjure.java.util.Primitives; import com.palantir.conjure.spec.ArgumentDefinition; import com.palantir.conjure.spec.AuthType; @@ -26,6 +28,7 @@ import com.palantir.conjure.spec.CookieAuthType; import com.palantir.conjure.spec.EndpointDefinition; import com.palantir.conjure.spec.EndpointName; +import com.palantir.conjure.spec.ErrorDefinition; import com.palantir.conjure.spec.ExternalReference; import com.palantir.conjure.spec.HeaderAuthType; import com.palantir.conjure.spec.HeaderParameterType; @@ -60,6 +63,7 @@ import com.palantir.javapoet.ParameterizedTypeName; import com.palantir.javapoet.TypeName; import com.palantir.javapoet.TypeSpec; +import com.palantir.javapoet.TypeVariableName; import com.palantir.logsafe.SafeArg; import com.palantir.logsafe.exceptions.SafeIllegalStateException; import java.util.List; @@ -103,6 +107,11 @@ public MethodSpec generate(ServiceDefinition def) { .initializer(CodeBlock.of("$L.plainSerDe()", StaticFactoryMethodGenerator.RUNTIME)) .build()); + if (options.deserializeErrorResponsesAsJson()) { + impl.addMethod(createHelperToConstructExceptionDeserializerArgs( + def.getServiceName().getPackage())); + } + def.getEndpoints().forEach(endpoint -> { endpoint.getArgs().stream() .filter(arg -> arg.getParamType().accept(ParameterTypeVisitor.IS_BODY)) @@ -131,6 +140,45 @@ public MethodSpec generate(ServiceDefinition def) { return method; } + private MethodSpec createHelperToConstructExceptionDeserializerArgs(String serviceDefinitionPackageName) { + List errorDefinitions = packageToErrorDefinitionsMapping.get(serviceDefinitionPackageName); + TypeVariableName typeVariableT = TypeVariableName.get("T"); + MethodSpec.Builder methodBuilder = MethodSpec.methodBuilder("createExceptionDeserializerArgs") + .addTypeVariable(typeVariableT) + .addModifiers(Modifier.PRIVATE) + .returns(ParameterizedTypeName.get(ClassName.get(ExceptionDeserializerArgs.class), typeVariableT)) + .addParameter(ParameterizedTypeName.get(ClassName.get(TypeMarker.class), typeVariableT), "returnType"); + + CodeBlock.Builder exceptions = CodeBlock.builder() + .add("return $T.<$T>builder()", ExceptionDeserializerArgs.class, typeVariableT) + .add(".returnType(returnType)"); + // Add exceptions from error definitions + for (ErrorDefinition errorDef : errorDefinitions) { + String errorName = errorDef.getErrorName().getName(); + ClassName errorClass = ClassName.get( + Packages.getPrefixedPackage(errorDef.getErrorName().getPackage(), options.packagePrefix()), + ErrorGenerationUtils.errorTypesClassName(errorDef.getNamespace()), + CaseFormat.UPPER_CAMEL.to(CaseFormat.UPPER_UNDERSCORE, errorName)); + ClassName serializableErrorClass = ClassName.get( + Packages.getPrefixedPackage(errorDef.getErrorName().getPackage(), options.packagePrefix()), + ErrorGenerationUtils.errorTypesClassName(errorDef.getNamespace()), + errorName + "SerializableError"); + ClassName exceptionClass = ClassName.get( + Packages.getPrefixedPackage(errorDef.getErrorName().getPackage(), options.packagePrefix()), + ErrorGenerationUtils.errorTypesClassName(errorDef.getNamespace()), + errorName + "Exception"); + exceptions.add( + ".exception($T.name(), new $T<$T>() {}, new $T<$T>() {})", + errorClass, + TypeMarker.class, + serializableErrorClass, + TypeMarker.class, + exceptionClass); + } + exceptions.add(".build();"); + return methodBuilder.addCode(exceptions.build()).build(); + } + private ClassName getClassName(ServiceDefinition def) { return methodType.switchBy(Names.blockingClassName(def, options), Names.asyncClassName(def, options)); } diff --git a/conjure-java-core/src/main/java/com/palantir/conjure/java/types/ErrorGenerator.java b/conjure-java-core/src/main/java/com/palantir/conjure/java/types/ErrorGenerator.java index 4f52eb8a4..55ca71e94 100644 --- a/conjure-java-core/src/main/java/com/palantir/conjure/java/types/ErrorGenerator.java +++ b/conjure-java-core/src/main/java/com/palantir/conjure/java/types/ErrorGenerator.java @@ -56,8 +56,8 @@ import java.util.Optional; import java.util.stream.Collectors; import java.util.stream.Stream; +import javax.annotation.Nullable; import javax.lang.model.element.Modifier; -import org.jspecify.annotations.Nullable; public final class ErrorGenerator implements Generator { From 0d5c0e8a7d15a82789aa843922d8ae401c0e7c58 Mon Sep 17 00:00:00 2001 From: Pritham Marupaka Date: Thu, 14 Aug 2025 00:20:47 -0400 Subject: [PATCH 13/26] Use new empty body, input stream and optional input stream deserializers --- conjure-java-client-verifier/build.gradle | 1 - .../product/EteBinaryServiceAsync.java | 57 ++++++++++--------- .../product/EteBinaryServiceBlocking.java | 51 ++++++++++------- .../com/palantir/product/EteServiceAsync.java | 29 +++++----- .../palantir/product/EteServiceBlocking.java | 29 +++++----- .../dialogue/test/api/CookieServiceAsync.java | 4 +- .../test/api/CookieServiceBlocking.java | 4 +- .../DefaultStaticFactoryMethodGenerator.java | 6 +- versions.lock | 22 +------ versions.props | 2 +- 10 files changed, 98 insertions(+), 107 deletions(-) diff --git a/conjure-java-client-verifier/build.gradle b/conjure-java-client-verifier/build.gradle index 8ecaf0032..3af24a118 100644 --- a/conjure-java-client-verifier/build.gradle +++ b/conjure-java-client-verifier/build.gradle @@ -66,7 +66,6 @@ project('verification-server-api') { api 'com.palantir.dialogue:dialogue-clients' api 'com.palantir.dialogue:dialogue-serde' - implementation 'com.fasterxml.jackson.core:jackson-annotations' implementation 'com.fasterxml.jackson.core:jackson-databind' implementation 'com.google.code.findbugs:jsr305' diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceAsync.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceAsync.java index 9aa1cc9cb..ef0f1fb0c 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceAsync.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceAsync.java @@ -5,6 +5,7 @@ import com.palantir.dialogue.BinaryRequestBody; import com.palantir.dialogue.Channel; import com.palantir.dialogue.ConjureRuntime; +import com.palantir.dialogue.Deserializer; import com.palantir.dialogue.DialogueService; import com.palantir.dialogue.DialogueServiceFactory; import com.palantir.dialogue.Endpoint; @@ -60,21 +61,43 @@ static EteBinaryServiceAsync of(EndpointChannelFactory _endpointChannelFactory, private final EndpointChannel postBinaryChannel = _endpointChannelFactory.endpoint(DialogueEteBinaryEndpoints.postBinary); + private final Deserializer postBinaryDeserializer = _runtime.bodySerDe() + .inputStreamDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final EndpointChannel postBinaryThrowsChannel = _endpointChannelFactory.endpoint(DialogueEteBinaryEndpoints.postBinaryThrows); + private final Deserializer postBinaryThrowsDeserializer = _runtime.bodySerDe() + .inputStreamDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final EndpointChannel getOptionalBinaryPresentChannel = _endpointChannelFactory.endpoint(DialogueEteBinaryEndpoints.getOptionalBinaryPresent); + private final Deserializer> getOptionalBinaryPresentDeserializer = + _runtime.bodySerDe() + .optionalInputStreamDeserializer( + createExceptionDeserializerArgs(new TypeMarker>() {})); + private final EndpointChannel getOptionalBinaryEmptyChannel = _endpointChannelFactory.endpoint(DialogueEteBinaryEndpoints.getOptionalBinaryEmpty); + private final Deserializer> getOptionalBinaryEmptyDeserializer = _runtime.bodySerDe() + .optionalInputStreamDeserializer( + createExceptionDeserializerArgs(new TypeMarker>() {})); + private final EndpointChannel getBinaryFailureChannel = _endpointChannelFactory.endpoint(DialogueEteBinaryEndpoints.getBinaryFailure); + private final Deserializer getBinaryFailureDeserializer = _runtime.bodySerDe() + .inputStreamDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final EndpointChannel getAliasedChannel = _endpointChannelFactory.endpoint(DialogueEteBinaryEndpoints.getAliased); + private final Deserializer> getAliasedDeserializer = _runtime.bodySerDe() + .optionalInputStreamDeserializer( + createExceptionDeserializerArgs(new TypeMarker>() {})); + private ExceptionDeserializerArgs createExceptionDeserializerArgs(TypeMarker returnType) { return ExceptionDeserializerArgs.builder() .returnType(returnType) @@ -118,11 +141,7 @@ public ListenableFuture postBinary(AuthHeader authHeader, BinaryReq .get() .toString()); } - return _runtime.clients() - .call( - postBinaryChannel, - _request.build(), - _runtime.bodySerDe().inputStreamDeserializer()); + return _runtime.clients().call(postBinaryChannel, _request.build(), postBinaryDeserializer); } @Override @@ -140,11 +159,7 @@ public ListenableFuture postBinaryThrows( .get() .toString()); } - return _runtime.clients() - .call( - postBinaryThrowsChannel, - _request.build(), - _runtime.bodySerDe().inputStreamDeserializer()); + return _runtime.clients().call(postBinaryThrowsChannel, _request.build(), postBinaryThrowsDeserializer); } @Override @@ -160,10 +175,7 @@ public ListenableFuture> getOptionalBinaryPresent(AuthHead .toString()); } return _runtime.clients() - .call( - getOptionalBinaryPresentChannel, - _request.build(), - _runtime.bodySerDe().optionalInputStreamDeserializer()); + .call(getOptionalBinaryPresentChannel, _request.build(), getOptionalBinaryPresentDeserializer); } @Override @@ -179,10 +191,7 @@ public ListenableFuture> getOptionalBinaryEmpty(AuthHeader .toString()); } return _runtime.clients() - .call( - getOptionalBinaryEmptyChannel, - _request.build(), - _runtime.bodySerDe().optionalInputStreamDeserializer()); + .call(getOptionalBinaryEmptyChannel, _request.build(), getOptionalBinaryEmptyDeserializer); } @Override @@ -200,11 +209,7 @@ public ListenableFuture getBinaryFailure( .get() .toString()); } - return _runtime.clients() - .call( - getBinaryFailureChannel, - _request.build(), - _runtime.bodySerDe().inputStreamDeserializer()); + return _runtime.clients().call(getBinaryFailureChannel, _request.build(), getBinaryFailureDeserializer); } @Override @@ -219,11 +224,7 @@ public ListenableFuture> getAliased(AuthHeader authHeader) .get() .toString()); } - return _runtime.clients() - .call( - getAliasedChannel, - _request.build(), - _runtime.bodySerDe().optionalInputStreamDeserializer()); + return _runtime.clients().call(getAliasedChannel, _request.build(), getAliasedDeserializer); } @Override diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceBlocking.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceBlocking.java index 632d94bca..89e2af16b 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceBlocking.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceBlocking.java @@ -5,6 +5,7 @@ import com.palantir.dialogue.BinaryRequestBody; import com.palantir.dialogue.Channel; import com.palantir.dialogue.ConjureRuntime; +import com.palantir.dialogue.Deserializer; import com.palantir.dialogue.DialogueService; import com.palantir.dialogue.DialogueServiceFactory; import com.palantir.dialogue.Endpoint; @@ -63,21 +64,43 @@ static EteBinaryServiceBlocking of(EndpointChannelFactory _endpointChannelFactor private final EndpointChannel postBinaryChannel = _endpointChannelFactory.endpoint(DialogueEteBinaryEndpoints.postBinary); + private final Deserializer postBinaryDeserializer = _runtime.bodySerDe() + .inputStreamDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final EndpointChannel postBinaryThrowsChannel = _endpointChannelFactory.endpoint(DialogueEteBinaryEndpoints.postBinaryThrows); + private final Deserializer postBinaryThrowsDeserializer = _runtime.bodySerDe() + .inputStreamDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final EndpointChannel getOptionalBinaryPresentChannel = _endpointChannelFactory.endpoint(DialogueEteBinaryEndpoints.getOptionalBinaryPresent); + private final Deserializer> getOptionalBinaryPresentDeserializer = + _runtime.bodySerDe() + .optionalInputStreamDeserializer( + createExceptionDeserializerArgs(new TypeMarker>() {})); + private final EndpointChannel getOptionalBinaryEmptyChannel = _endpointChannelFactory.endpoint(DialogueEteBinaryEndpoints.getOptionalBinaryEmpty); + private final Deserializer> getOptionalBinaryEmptyDeserializer = _runtime.bodySerDe() + .optionalInputStreamDeserializer( + createExceptionDeserializerArgs(new TypeMarker>() {})); + private final EndpointChannel getBinaryFailureChannel = _endpointChannelFactory.endpoint(DialogueEteBinaryEndpoints.getBinaryFailure); + private final Deserializer getBinaryFailureDeserializer = _runtime.bodySerDe() + .inputStreamDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final EndpointChannel getAliasedChannel = _endpointChannelFactory.endpoint(DialogueEteBinaryEndpoints.getAliased); + private final Deserializer> getAliasedDeserializer = _runtime.bodySerDe() + .optionalInputStreamDeserializer( + createExceptionDeserializerArgs(new TypeMarker>() {})); + private ExceptionDeserializerArgs createExceptionDeserializerArgs(TypeMarker returnType) { return ExceptionDeserializerArgs.builder() .returnType(returnType) @@ -121,11 +144,7 @@ public InputStream postBinary(AuthHeader authHeader, BinaryRequestBody body) { .get() .toString()); } - return _runtime.clients() - .callBlocking( - postBinaryChannel, - _request.build(), - _runtime.bodySerDe().inputStreamDeserializer()); + return _runtime.clients().callBlocking(postBinaryChannel, _request.build(), postBinaryDeserializer); } @Override @@ -143,10 +162,7 @@ public InputStream postBinaryThrows(AuthHeader authHeader, int bytesToRead, Bina .toString()); } return _runtime.clients() - .callBlocking( - postBinaryThrowsChannel, - _request.build(), - _runtime.bodySerDe().inputStreamDeserializer()); + .callBlocking(postBinaryThrowsChannel, _request.build(), postBinaryThrowsDeserializer); } @Override @@ -165,7 +181,7 @@ public Optional getOptionalBinaryPresent(AuthHeader authHeader) { .callBlocking( getOptionalBinaryPresentChannel, _request.build(), - _runtime.bodySerDe().optionalInputStreamDeserializer()); + getOptionalBinaryPresentDeserializer); } @Override @@ -182,9 +198,7 @@ public Optional getOptionalBinaryEmpty(AuthHeader authHeader) { } return _runtime.clients() .callBlocking( - getOptionalBinaryEmptyChannel, - _request.build(), - _runtime.bodySerDe().optionalInputStreamDeserializer()); + getOptionalBinaryEmptyChannel, _request.build(), getOptionalBinaryEmptyDeserializer); } @Override @@ -202,10 +216,7 @@ public InputStream getBinaryFailure(AuthHeader authHeader, int numBytes, boolean .toString()); } return _runtime.clients() - .callBlocking( - getBinaryFailureChannel, - _request.build(), - _runtime.bodySerDe().inputStreamDeserializer()); + .callBlocking(getBinaryFailureChannel, _request.build(), getBinaryFailureDeserializer); } @Override @@ -220,11 +231,7 @@ public Optional getAliased(AuthHeader authHeader) { .get() .toString()); } - return _runtime.clients() - .callBlocking( - getAliasedChannel, - _request.build(), - _runtime.bodySerDe().optionalInputStreamDeserializer()); + return _runtime.clients().callBlocking(getAliasedChannel, _request.build(), getAliasedDeserializer); } @Override diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceAsync.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceAsync.java index 7d1aae227..a900c7767 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceAsync.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceAsync.java @@ -277,6 +277,9 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur private final EndpointChannel binaryChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.binary); + private final Deserializer binaryDeserializer = _runtime.bodySerDe() + .inputStreamDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final EndpointChannel pathChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.path); private final Deserializer pathDeserializer = @@ -359,8 +362,8 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur private final EndpointChannel noReturnChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.noReturn); - private final Deserializer noReturnDeserializer = - _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final Deserializer noReturnDeserializer = _runtime.bodySerDe() + .emptyBodyDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel enumQueryChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.enumQuery); @@ -407,8 +410,8 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur private final EndpointChannel complexQueryParametersChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.complexQueryParameters); - private final Deserializer complexQueryParametersDeserializer = - _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final Deserializer complexQueryParametersDeserializer = _runtime.bodySerDe() + .emptyBodyDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final Serializer>> receiveListOfOptionalsSerializer = _runtime.bodySerDe().serializer(new TypeMarker>>() {}); @@ -416,8 +419,8 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur private final EndpointChannel receiveListOfOptionalsChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.receiveListOfOptionals); - private final Deserializer receiveListOfOptionalsDeserializer = - _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final Deserializer receiveListOfOptionalsDeserializer = _runtime.bodySerDe() + .emptyBodyDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final Serializer>> receiveSetOfOptionalsSerializer = _runtime.bodySerDe().serializer(new TypeMarker>>() {}); @@ -425,8 +428,8 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur private final EndpointChannel receiveSetOfOptionalsChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.receiveSetOfOptionals); - private final Deserializer receiveSetOfOptionalsDeserializer = - _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final Deserializer receiveSetOfOptionalsDeserializer = _runtime.bodySerDe() + .emptyBodyDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final Serializer> receiveListOfStringsSerializer = _runtime.bodySerDe().serializer(new TypeMarker>() {}); @@ -434,8 +437,8 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur private final EndpointChannel receiveListOfStringsChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.receiveListOfStrings); - private final Deserializer receiveListOfStringsDeserializer = - _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final Deserializer receiveListOfStringsDeserializer = _runtime.bodySerDe() + .emptyBodyDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private ExceptionDeserializerArgs createExceptionDeserializerArgs(TypeMarker returnType) { return ExceptionDeserializerArgs.builder() @@ -629,11 +632,7 @@ public ListenableFuture binary(AuthHeader authHeader) { .get() .toString()); } - return _runtime.clients() - .call( - binaryChannel, - _request.build(), - _runtime.bodySerDe().inputStreamDeserializer()); + return _runtime.clients().call(binaryChannel, _request.build(), binaryDeserializer); } @Override diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceBlocking.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceBlocking.java index 6790d2d84..29908316a 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceBlocking.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceBlocking.java @@ -276,6 +276,9 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con private final EndpointChannel binaryChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.binary); + private final Deserializer binaryDeserializer = _runtime.bodySerDe() + .inputStreamDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final EndpointChannel pathChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.path); private final Deserializer pathDeserializer = @@ -358,8 +361,8 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con private final EndpointChannel noReturnChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.noReturn); - private final Deserializer noReturnDeserializer = - _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final Deserializer noReturnDeserializer = _runtime.bodySerDe() + .emptyBodyDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel enumQueryChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.enumQuery); @@ -406,8 +409,8 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con private final EndpointChannel complexQueryParametersChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.complexQueryParameters); - private final Deserializer complexQueryParametersDeserializer = - _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final Deserializer complexQueryParametersDeserializer = _runtime.bodySerDe() + .emptyBodyDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final Serializer>> receiveListOfOptionalsSerializer = _runtime.bodySerDe().serializer(new TypeMarker>>() {}); @@ -415,8 +418,8 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con private final EndpointChannel receiveListOfOptionalsChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.receiveListOfOptionals); - private final Deserializer receiveListOfOptionalsDeserializer = - _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final Deserializer receiveListOfOptionalsDeserializer = _runtime.bodySerDe() + .emptyBodyDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final Serializer>> receiveSetOfOptionalsSerializer = _runtime.bodySerDe().serializer(new TypeMarker>>() {}); @@ -424,8 +427,8 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con private final EndpointChannel receiveSetOfOptionalsChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.receiveSetOfOptionals); - private final Deserializer receiveSetOfOptionalsDeserializer = - _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final Deserializer receiveSetOfOptionalsDeserializer = _runtime.bodySerDe() + .emptyBodyDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final Serializer> receiveListOfStringsSerializer = _runtime.bodySerDe().serializer(new TypeMarker>() {}); @@ -433,8 +436,8 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con private final EndpointChannel receiveListOfStringsChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.receiveListOfStrings); - private final Deserializer receiveListOfStringsDeserializer = - _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final Deserializer receiveListOfStringsDeserializer = _runtime.bodySerDe() + .emptyBodyDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private ExceptionDeserializerArgs createExceptionDeserializerArgs(TypeMarker returnType) { return ExceptionDeserializerArgs.builder() @@ -630,11 +633,7 @@ public InputStream binary(AuthHeader authHeader) { .get() .toString()); } - return _runtime.clients() - .callBlocking( - binaryChannel, - _request.build(), - _runtime.bodySerDe().inputStreamDeserializer()); + return _runtime.clients().callBlocking(binaryChannel, _request.build(), binaryDeserializer); } @Override diff --git a/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceAsync.java b/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceAsync.java index 346cefe41..d55202085 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceAsync.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceAsync.java @@ -35,8 +35,8 @@ static CookieServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Con private final EndpointChannel eatCookiesChannel = _endpointChannelFactory.endpoint(DialogueCookieEndpoints.eatCookies); - private final Deserializer eatCookiesDeserializer = - _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final Deserializer eatCookiesDeserializer = _runtime.bodySerDe() + .emptyBodyDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private ExceptionDeserializerArgs createExceptionDeserializerArgs(TypeMarker returnType) { return ExceptionDeserializerArgs.builder() diff --git a/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceBlocking.java b/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceBlocking.java index ad73ae830..78fc39e12 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceBlocking.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceBlocking.java @@ -34,8 +34,8 @@ static CookieServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, private final EndpointChannel eatCookiesChannel = _endpointChannelFactory.endpoint(DialogueCookieEndpoints.eatCookies); - private final Deserializer eatCookiesDeserializer = - _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final Deserializer eatCookiesDeserializer = _runtime.bodySerDe() + .emptyBodyDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private ExceptionDeserializerArgs createExceptionDeserializerArgs(TypeMarker returnType) { return ExceptionDeserializerArgs.builder() diff --git a/conjure-java-core/src/main/java/com/palantir/conjure/java/services/dialogue/DefaultStaticFactoryMethodGenerator.java b/conjure-java-core/src/main/java/com/palantir/conjure/java/services/dialogue/DefaultStaticFactoryMethodGenerator.java index 14ea52f15..1466d6f23 100644 --- a/conjure-java-core/src/main/java/com/palantir/conjure/java/services/dialogue/DefaultStaticFactoryMethodGenerator.java +++ b/conjure-java-core/src/main/java/com/palantir/conjure/java/services/dialogue/DefaultStaticFactoryMethodGenerator.java @@ -15,6 +15,7 @@ */ package com.palantir.conjure.java.services.dialogue; +import com.google.common.base.CaseFormat; import com.google.common.collect.ImmutableMap; import com.palantir.conjure.java.Options; import com.palantir.conjure.java.services.Auth; @@ -213,7 +214,7 @@ private Optional serializer(EndpointName endpointName, Type type) { private Optional deserializer(EndpointName endpointName, Optional type) { TypeName className = Primitives.box(returnTypes.baseType(type)); - if (returnTypes.isBinaryOrOptionalBinary(className)) { + if (returnTypes.isBinaryOrOptionalBinary(className) && !options.deserializeErrorResponsesAsJson()) { return Optional.empty(); } @@ -292,7 +293,8 @@ private MethodSpec clientImpl(EndpointDefinition def) { Names.endpointChannel(def), REQUEST, def.getReturns() - .filter(type -> returnTypes.isBinaryOrOptionalBinary(returnTypes.baseType(type))) + .filter(type -> !options.deserializeErrorResponsesAsJson() + && returnTypes.isBinaryOrOptionalBinary(returnTypes.baseType(type))) .map(type -> StaticFactoryMethodGenerator.RUNTIME + (returnTypes.isOptionalBinary(returnTypes.baseType(type)) ? ".bodySerDe().optionalInputStreamDeserializer()" diff --git a/versions.lock b/versions.lock index cd8a2450d..50564b747 100644 --- a/versions.lock +++ b/versions.lock @@ -44,19 +44,11 @@ com.palantir.conjure:conjure-api-objects:4.50.0 (3 constraints: 9327531f) com.palantir.conjure:conjure-generator-common:4.50.0 (2 constraints: fd13a782) -<<<<<<< HEAD com.palantir.conjure.java.api:errors:2.64.0 (8 constraints: a094bf79) com.palantir.conjure.java.api:service-config:2.64.0 (6 constraints: 3466fcd7) com.palantir.conjure.java.api:ssl-config:2.64.0 (5 constraints: b44fa72d) -======= -com.palantir.conjure.java.api:errors:2.62.0-10-g6a81a18 (8 constraints: 749a93bb) - -com.palantir.conjure.java.api:service-config:2.62.0-10-g6a81a18 (6 constraints: 1e697150) - -com.palantir.conjure.java.api:ssl-config:2.62.0-10-g6a81a18 (5 constraints: 8855770a) ->>>>>>> 86e910bd (wip code-gen) com.palantir.conjure.java.runtime:client-config:8.24.0 (6 constraints: ab6bbb28) @@ -72,15 +64,15 @@ com.palantir.dialogue:dialogue-apache-hc5-client:6.7.0 (2 constraints: 1a2974b6) com.palantir.dialogue:dialogue-blocking-channels:6.7.0 (2 constraints: 79232973) -com.palantir.dialogue:dialogue-clients:6.7.0 (1 constraints: ce07ab7d) +com.palantir.dialogue:dialogue-clients:6.7.0 (1 constraints: cc07a77c) com.palantir.dialogue:dialogue-core:6.7.0 (3 constraints: ea3c6541) com.palantir.dialogue:dialogue-futures:6.7.0 (3 constraints: 3e33a938) -com.palantir.dialogue:dialogue-serde:6.7.0 (3 constraints: e73072b5) +com.palantir.dialogue:dialogue-serde:6.7.0 (3 constraints: e53088b3) -com.palantir.dialogue:dialogue-target:6.7.0 (7 constraints: 907a6316) +com.palantir.dialogue:dialogue-target:6.7.0 (7 constraints: 8e7ae112) com.palantir.goethe:goethe:0.16.0 (1 constraints: 3905353b) @@ -180,11 +172,7 @@ org.glassfish.jersey.core:jersey-common:3.1.3 (15 constraints: 7410a287) org.hdrhistogram:HdrHistogram:2.2.2 (1 constraints: 0e100092) -<<<<<<< HEAD org.immutables:value:2.11.3 (2 constraints: 0215eac1) -======= -org.immutables:value:2.11.3 (2 constraints: 0115e9c1) ->>>>>>> 86e910bd (wip code-gen) org.jboss.logging:jboss-logging:3.5.0.Final (9 constraints: 89ae085f) @@ -250,11 +238,7 @@ com.netflix.feign:feign-jackson:8.18.0 (1 constraints: c718909e) com.palantir.conjure:conjure-core:4.50.0 (1 constraints: 3b054b3b) -<<<<<<< HEAD com.palantir.conjure.java.api:test-utils:2.64.0 (1 constraints: 3e054f3b) -======= -com.palantir.conjure.java.api:test-utils:2.62.0-10-g6a81a18 (1 constraints: 2808568c) ->>>>>>> 86e910bd (wip code-gen) com.palantir.conjure.java.runtime:conjure-java-annotations:8.24.0 (1 constraints: c418889e) diff --git a/versions.props b/versions.props index ccb12b90b..2b45a4f08 100644 --- a/versions.props +++ b/versions.props @@ -12,7 +12,7 @@ com.palantir.conjure.verification:* = 0.19.0 com.palantir.conjure:* = 4.50.0 com.palantir.deadlines:* = 0.15.0 com.palantir.goethe:* = 0.16.0 -com.palantir.dialogue:* = 6.4.0-7-g74a1e71 +com.palantir.dialogue:* = 6.4.0-9-g24023fe com.palantir.human-readable-types:* = 1.7.0 com.palantir.javapoet:javapoet = 0.7.0 com.palantir.ri:resource-identifier = 2.11.0 From 5f56b9925f0343763e7cd7cc9d4e4752dcf99dcd Mon Sep 17 00:00:00 2001 From: Pritham Marupaka Date: Thu, 14 Aug 2025 23:04:45 -0400 Subject: [PATCH 14/26] change flag name --- .../java/com/palantir/conjure/java/Options.java | 6 ++++-- .../DefaultStaticFactoryMethodGenerator.java | 10 +++++----- .../conjure/java/parameterized/TestCases.java | 2 +- .../palantir/conjure/java/cli/ConjureJavaCli.java | 14 +++++++++++--- 4 files changed, 21 insertions(+), 11 deletions(-) diff --git a/conjure-java-core/src/main/java/com/palantir/conjure/java/Options.java b/conjure-java-core/src/main/java/com/palantir/conjure/java/Options.java index b412e24e6..0d06eb902 100644 --- a/conjure-java-core/src/main/java/com/palantir/conjure/java/Options.java +++ b/conjure-java-core/src/main/java/com/palantir/conjure/java/Options.java @@ -203,11 +203,13 @@ default boolean dangerousDoNotUseEnableEndpointAssociatedErrors() { } /** - * TODO. + * Enabling this flag will lead to the generation of Dialogue client interfaces that are able to send a header to + * servers specifying the Conjure error parameter serialization format they expect, and create custom exceptions for + * each error defined in the service's package. */ @Value.Default @Beta - default boolean deserializeErrorResponsesAsJson() { + default boolean generateErrorParameterFormatRespectingDialogueInterfaces() { return false; } diff --git a/conjure-java-core/src/main/java/com/palantir/conjure/java/services/dialogue/DefaultStaticFactoryMethodGenerator.java b/conjure-java-core/src/main/java/com/palantir/conjure/java/services/dialogue/DefaultStaticFactoryMethodGenerator.java index 1466d6f23..4ed04ae52 100644 --- a/conjure-java-core/src/main/java/com/palantir/conjure/java/services/dialogue/DefaultStaticFactoryMethodGenerator.java +++ b/conjure-java-core/src/main/java/com/palantir/conjure/java/services/dialogue/DefaultStaticFactoryMethodGenerator.java @@ -108,7 +108,7 @@ public MethodSpec generate(ServiceDefinition def) { .initializer(CodeBlock.of("$L.plainSerDe()", StaticFactoryMethodGenerator.RUNTIME)) .build()); - if (options.deserializeErrorResponsesAsJson()) { + if (options.generateErrorParameterFormatRespectingDialogueInterfaces()) { impl.addMethod(createHelperToConstructExceptionDeserializerArgs( def.getServiceName().getPackage())); } @@ -214,7 +214,8 @@ private Optional serializer(EndpointName endpointName, Type type) { private Optional deserializer(EndpointName endpointName, Optional type) { TypeName className = Primitives.box(returnTypes.baseType(type)); - if (returnTypes.isBinaryOrOptionalBinary(className) && !options.deserializeErrorResponsesAsJson()) { + if (returnTypes.isBinaryOrOptionalBinary(className) + && !options.generateErrorParameterFormatRespectingDialogueInterfaces()) { return Optional.empty(); } @@ -224,10 +225,9 @@ private Optional deserializer(EndpointName endpointName, Optional !options.deserializeErrorResponsesAsJson() + .filter(type -> !options.generateErrorParameterFormatRespectingDialogueInterfaces() && returnTypes.isBinaryOrOptionalBinary(returnTypes.baseType(type))) .map(type -> StaticFactoryMethodGenerator.RUNTIME + (returnTypes.isOptionalBinary(returnTypes.baseType(type)) diff --git a/conjure-java-core/src/test/java/com/palantir/conjure/java/parameterized/TestCases.java b/conjure-java-core/src/test/java/com/palantir/conjure/java/parameterized/TestCases.java index 6cf03b797..b6600982f 100644 --- a/conjure-java-core/src/test/java/com/palantir/conjure/java/parameterized/TestCases.java +++ b/conjure-java-core/src/test/java/com/palantir/conjure/java/parameterized/TestCases.java @@ -178,7 +178,7 @@ public final class TestCases { .files(Path.of("example-errors.yml")) .options(Options.builder() .apiVersion("1.2.3") - .deserializeErrorResponsesAsJson(true) + .generateErrorParameterFormatRespectingDialogueInterfaces(true) .build()) .generatorTypes(List.of(GeneratorType.DIALOGUE, GeneratorType.OBJECT, GeneratorType.ERROR)) .build()) diff --git a/conjure-java/src/main/java/com/palantir/conjure/java/cli/ConjureJavaCli.java b/conjure-java/src/main/java/com/palantir/conjure/java/cli/ConjureJavaCli.java index f477ff556..7209a789e 100644 --- a/conjure-java/src/main/java/com/palantir/conjure/java/cli/ConjureJavaCli.java +++ b/conjure-java/src/main/java/com/palantir/conjure/java/cli/ConjureJavaCli.java @@ -246,8 +246,15 @@ public static final class GenerateCommand implements Runnable { + "This feature is currently not supported.") private boolean dangerousDoNotUseEnableEndpointAssociatedErrors; - @CommandLine.Option(names = "--deserializeErrorResponsesAsJson", defaultValue = "false", description = "TODO.") - private boolean deserializeErrorResponsesAsJson; + @CommandLine.Option( + names = "--generateErrorParameterFormatRespectingDialogueInterfaces", + defaultValue = "false", + description = + "Enabling this flag will lead to the generation of Dialogue client interfaces that are able to" + + " send a header to servers specifying the Conjure error parameter serialization format" + + " they expect, and create custom exceptions foreach error defined in the service's" + + " package.") + private boolean generateErrorParameterFormatRespectingDialogueInterfaces; @SuppressWarnings("unused") @CommandLine.Unmatched @@ -323,7 +330,8 @@ CliConfiguration getConfiguration() { .defensiveCollections(defensiveCollections) .dangerousDoNotUseEnableEndpointAssociatedErrors( dangerousDoNotUseEnableEndpointAssociatedErrors) - .deserializeErrorResponsesAsJson(deserializeErrorResponsesAsJson) + .generateErrorParameterFormatRespectingDialogueInterfaces( + generateErrorParameterFormatRespectingDialogueInterfaces) .build()) .build(); } From b8fdd54297e0cb5803c993d9e26b4aa1e9ffbf0c Mon Sep 17 00:00:00 2001 From: Pritham Marupaka Date: Mon, 18 Aug 2025 15:17:23 -0400 Subject: [PATCH 15/26] update locks and fix merge --- .../com/palantir/another/ConjureErrors.java | 40 ++++ .../com/palantir/product/ConjureErrors.java | 178 +++++++---------- .../palantir/product/ConjureJavaErrors.java | 20 +- .../another/EndpointSpecificErrors.java | 21 +- .../com/palantir/product/ConjureErrors.java | 26 +-- .../product/EndpointSpecificErrors.java | 25 +-- .../product/EndpointSpecificTwoErrors.java | 21 +- .../com/palantir/product/TestErrors.java | 69 +++---- .../com/palantir/another/ConjureErrors.java | 36 ++-- .../another/ConjureJavaOtherErrors.java | 20 +- .../com/palantir/product/ConjureErrors.java | 180 +++++++----------- .../palantir/product/ConjureJavaErrors.java | 20 +- .../another/EndpointSpecificErrors.java | 21 +- .../com/palantir/product/ConjureErrors.java | 26 +-- .../product/EndpointSpecificErrors.java | 25 +-- .../product/EndpointSpecificTwoErrors.java | 21 +- .../com/palantir/product/TestErrors.java | 69 +++---- .../conjure/java/types/ErrorGenerator.java | 34 +--- .../conjure/java/UndertowServiceEteTest.java | 34 +++- .../java/undertow/runtime/ConjureError.java | 54 +----- .../undertow/runtime/ConjureExceptions.java | 30 +-- 21 files changed, 353 insertions(+), 617 deletions(-) diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/another/ConjureErrors.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/another/ConjureErrors.java index cdba5e331..541f49c2b 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/another/ConjureErrors.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/another/ConjureErrors.java @@ -1,9 +1,14 @@ package dialogue.com.palantir.another; +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.palantir.conjure.java.api.errors.AbstractSerializableError; import com.palantir.conjure.java.api.errors.ErrorType; import com.palantir.conjure.java.api.errors.RemoteException; +import com.palantir.conjure.java.api.errors.SerializableError; import com.palantir.conjure.java.api.errors.ServiceException; import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.Safe; import javax.annotation.Nullable; import javax.annotation.processing.Generated; @@ -39,4 +44,39 @@ public static boolean isDifferentPackageError(RemoteException remoteException) { Preconditions.checkNotNull(remoteException, "remote exception must not be null"); return DIFFERENT_PACKAGE_ERROR.name().equals(remoteException.getError().errorName()); } + + public static record DifferentPackageErrorParameters() {} + + public static final class DifferentPackageErrorSerializableError + extends AbstractSerializableError { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + DifferentPackageErrorSerializableError( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorName") @Safe String errorName, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") DifferentPackageErrorParameters parameters) { + super(errorCode, errorName, errorInstanceId, parameters); + } + + public SerializableError toSerializableError() { + return SerializableError.builder() + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()) + .build(); + } + } + + public static final class DifferentPackageErrorException extends RemoteException { + private DifferentPackageErrorSerializableError error; + + public DifferentPackageErrorException(DifferentPackageErrorSerializableError error, int status) { + super(error.toSerializableError(), status); + this.error = error; + } + + public DifferentPackageErrorSerializableError error() { + return error; + } + } } diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureErrors.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureErrors.java index 4407db328..bf459d411 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureErrors.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureErrors.java @@ -12,7 +12,6 @@ import com.palantir.logsafe.SafeArg; import com.palantir.logsafe.Unsafe; import com.palantir.logsafe.UnsafeArg; -import java.util.Map; import java.util.Objects; import javax.annotation.Nullable; import javax.annotation.processing.Generated; @@ -367,183 +366,136 @@ public static record InvalidTypeDefinitionParameters( public static final class ConflictingCauseSafeArgSerializableError extends AbstractSerializableError { - @Nullable - private final Map legacyParameters; - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) ConflictingCauseSafeArgSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") ConflictingCauseSafeArgParameters parameters, - @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { + @JsonProperty("parameters") ConflictingCauseSafeArgParameters parameters) { super(errorCode, errorName, errorInstanceId, parameters); - this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder(); - if (legacyParameters != null) { - builder.putAllParameters(legacyParameters); - } else { - builder.putParameters("cause", Objects.toString(parameters().cause_())) - .putParameters( - "shouldThrow", Objects.toString(parameters().shouldThrow_())); - } - builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); - return builder.build(); + return SerializableError.builder() + .putParameters("cause", Objects.toString(parameters().cause_())) + .putParameters("shouldThrow", Objects.toString(parameters().shouldThrow_())) + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()) + .build(); } } public static final class ConflictingCauseUnsafeArgSerializableError extends AbstractSerializableError { - @Nullable - private final Map legacyParameters; - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) ConflictingCauseUnsafeArgSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") ConflictingCauseUnsafeArgParameters parameters, - @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { + @JsonProperty("parameters") ConflictingCauseUnsafeArgParameters parameters) { super(errorCode, errorName, errorInstanceId, parameters); - this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder(); - if (legacyParameters != null) { - builder.putAllParameters(legacyParameters); - } else { - builder.putParameters("cause", Objects.toString(parameters().cause_())) - .putParameters( - "shouldThrow", Objects.toString(parameters().shouldThrow_())); - } - builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); - return builder.build(); + return SerializableError.builder() + .putParameters("cause", Objects.toString(parameters().cause_())) + .putParameters("shouldThrow", Objects.toString(parameters().shouldThrow_())) + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()) + .build(); } } public static final class ErrorWithComplexArgsSerializableError extends AbstractSerializableError { - @Nullable - private final Map legacyParameters; - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) ErrorWithComplexArgsSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") ErrorWithComplexArgsParameters parameters, - @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { + @JsonProperty("parameters") ErrorWithComplexArgsParameters parameters) { super(errorCode, errorName, errorInstanceId, parameters); - this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder(); - if (legacyParameters != null) { - builder.putAllParameters(legacyParameters); - } else { - builder.putParameters( - "primitiveExample", - Objects.toString(parameters().primitiveExample())) - .putParameters( - "collectionExample", - Objects.toString(parameters().collectionExample())) - .putParameters( - "nestedCollectionExample", - Objects.toString(parameters().nestedCollectionExample())) - .putParameters( - "optionalExample", Objects.toString(parameters().optionalExample())) - .putParameters( - "objectReference", Objects.toString(parameters().objectReference())) - .putParameters( - "unionExample", Objects.toString(parameters().unionExample())) - .putParameters( - "enumExample", Objects.toString(parameters().enumExample())) - .putParameters( - "stringAlias", Objects.toString(parameters().stringAlias())) - .putParameters( - "optionalAlias", Objects.toString(parameters().optionalAlias())) - .putParameters( - "collectionAlias", Objects.toString(parameters().collectionAlias())) - .putParameters( - "nestedAlias", Objects.toString(parameters().nestedAlias())) - .putParameters( - "externalExample", Objects.toString(parameters().externalExample())) - .putParameters( - "anyExample", Objects.toString(parameters().anyExample())) - .putParameters( - "emptyObject", Objects.toString(parameters().emptyObject())) - .putParameters( - "complexExample", Objects.toString(parameters().complexExample())) - .putParameters( - "safetyExample", Objects.toString(parameters().safetyExample())); - } - builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); - return builder.build(); + return SerializableError.builder() + .putParameters( + "primitiveExample", Objects.toString(parameters().primitiveExample())) + .putParameters( + "collectionExample", Objects.toString(parameters().collectionExample())) + .putParameters( + "nestedCollectionExample", + Objects.toString(parameters().nestedCollectionExample())) + .putParameters( + "optionalExample", Objects.toString(parameters().optionalExample())) + .putParameters( + "objectReference", Objects.toString(parameters().objectReference())) + .putParameters("unionExample", Objects.toString(parameters().unionExample())) + .putParameters("enumExample", Objects.toString(parameters().enumExample())) + .putParameters("stringAlias", Objects.toString(parameters().stringAlias())) + .putParameters( + "optionalAlias", Objects.toString(parameters().optionalAlias())) + .putParameters( + "collectionAlias", Objects.toString(parameters().collectionAlias())) + .putParameters("nestedAlias", Objects.toString(parameters().nestedAlias())) + .putParameters( + "externalExample", Objects.toString(parameters().externalExample())) + .putParameters("anyExample", Objects.toString(parameters().anyExample())) + .putParameters("emptyObject", Objects.toString(parameters().emptyObject())) + .putParameters( + "complexExample", Objects.toString(parameters().complexExample())) + .putParameters( + "safetyExample", Objects.toString(parameters().safetyExample())) + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()) + .build(); } } public static final class InvalidServiceDefinitionSerializableError extends AbstractSerializableError { - @Nullable - private final Map legacyParameters; - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) InvalidServiceDefinitionSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") InvalidServiceDefinitionParameters parameters, - @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { + @JsonProperty("parameters") InvalidServiceDefinitionParameters parameters) { super(errorCode, errorName, errorInstanceId, parameters); - this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder(); - if (legacyParameters != null) { - builder.putAllParameters(legacyParameters); - } else { - builder.putParameters( - "serviceName", Objects.toString(parameters().serviceName())) - .putParameters( - "serviceDef", Objects.toString(parameters().serviceDef())); - } - builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); - return builder.build(); + return SerializableError.builder() + .putParameters("serviceName", Objects.toString(parameters().serviceName())) + .putParameters("serviceDef", Objects.toString(parameters().serviceDef())) + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()) + .build(); } } public static final class InvalidTypeDefinitionSerializableError extends AbstractSerializableError { - @Nullable - private final Map legacyParameters; - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) InvalidTypeDefinitionSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") InvalidTypeDefinitionParameters parameters, - @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { + @JsonProperty("parameters") InvalidTypeDefinitionParameters parameters) { super(errorCode, errorName, errorInstanceId, parameters); - this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder(); - if (legacyParameters != null) { - builder.putAllParameters(legacyParameters); - } else { - builder.putParameters("typeName", Objects.toString(parameters().typeName())) - .putParameters("typeDef", Objects.toString(parameters().typeDef())); - } - builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); - return builder.build(); + return SerializableError.builder() + .putParameters("typeName", Objects.toString(parameters().typeName())) + .putParameters("typeDef", Objects.toString(parameters().typeDef())) + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()) + .build(); } } diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureJavaErrors.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureJavaErrors.java index d8774cdf5..35e2e7d77 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureJavaErrors.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureJavaErrors.java @@ -9,7 +9,6 @@ import com.palantir.conjure.java.api.errors.ServiceException; import com.palantir.logsafe.Preconditions; import com.palantir.logsafe.Safe; -import java.util.Map; import javax.annotation.Nullable; import javax.annotation.processing.Generated; @@ -49,28 +48,21 @@ public static record JavaCompilationFailedParameters() {} public static final class JavaCompilationFailedSerializableError extends AbstractSerializableError { - @Nullable - private final Map legacyParameters; - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) JavaCompilationFailedSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") JavaCompilationFailedParameters parameters, - @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { + @JsonProperty("parameters") JavaCompilationFailedParameters parameters) { super(errorCode, errorName, errorInstanceId, parameters); - this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder(); - if (legacyParameters != null) { - builder.putAllParameters(legacyParameters); - } else { - } - builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); - return builder.build(); + return SerializableError.builder() + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()) + .build(); } } diff --git a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/another/EndpointSpecificErrors.java b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/another/EndpointSpecificErrors.java index 7250238d2..ca932a3cc 100644 --- a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/another/EndpointSpecificErrors.java +++ b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/another/EndpointSpecificErrors.java @@ -8,8 +8,6 @@ import com.palantir.conjure.java.api.errors.SerializableError; import com.palantir.logsafe.Preconditions; import com.palantir.logsafe.Safe; -import java.util.Map; -import javax.annotation.Nullable; import javax.annotation.processing.Generated; @Generated("com.palantir.conjure.java.types.ErrorGenerator") @@ -30,28 +28,21 @@ public static record DifferentPackageParameters() {} public static final class DifferentPackageSerializableError extends AbstractSerializableError { - @Nullable - private final Map legacyParameters; - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) DifferentPackageSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") DifferentPackageParameters parameters, - @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { + @JsonProperty("parameters") DifferentPackageParameters parameters) { super(errorCode, errorName, errorInstanceId, parameters); - this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder(); - if (legacyParameters != null) { - builder.putAllParameters(legacyParameters); - } else { - } - builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); - return builder.build(); + return SerializableError.builder() + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()) + .build(); } } diff --git a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ConjureErrors.java b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ConjureErrors.java index 93b10f640..ec5f3ff40 100644 --- a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ConjureErrors.java +++ b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ConjureErrors.java @@ -8,9 +8,7 @@ import com.palantir.conjure.java.api.errors.SerializableError; import com.palantir.logsafe.Preconditions; import com.palantir.logsafe.Safe; -import java.util.Map; import java.util.Objects; -import javax.annotation.Nullable; import javax.annotation.processing.Generated; @Generated("com.palantir.conjure.java.types.ErrorGenerator") @@ -34,31 +32,23 @@ public static record ConflictingCauseSafeArgErrParameters( public static final class ConflictingCauseSafeArgErrSerializableError extends AbstractSerializableError { - @Nullable - private final Map legacyParameters; - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) ConflictingCauseSafeArgErrSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") ConflictingCauseSafeArgErrParameters parameters, - @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { + @JsonProperty("parameters") ConflictingCauseSafeArgErrParameters parameters) { super(errorCode, errorName, errorInstanceId, parameters); - this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder(); - if (legacyParameters != null) { - builder.putAllParameters(legacyParameters); - } else { - builder.putParameters("cause", Objects.toString(parameters().cause_())) - .putParameters( - "shouldThrow", Objects.toString(parameters().shouldThrow_())); - } - builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); - return builder.build(); + return SerializableError.builder() + .putParameters("cause", Objects.toString(parameters().cause_())) + .putParameters("shouldThrow", Objects.toString(parameters().shouldThrow_())) + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()) + .build(); } } diff --git a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/EndpointSpecificErrors.java b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/EndpointSpecificErrors.java index e1dd3226e..24f857a1d 100644 --- a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/EndpointSpecificErrors.java +++ b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/EndpointSpecificErrors.java @@ -9,9 +9,7 @@ import com.palantir.logsafe.Preconditions; import com.palantir.logsafe.Safe; import com.palantir.logsafe.Unsafe; -import java.util.Map; import java.util.Objects; -import javax.annotation.Nullable; import javax.annotation.processing.Generated; @Generated("com.palantir.conjure.java.types.ErrorGenerator") @@ -33,30 +31,23 @@ public static record EndpointErrorParameters( public static final class EndpointErrorSerializableError extends AbstractSerializableError { - @Nullable - private final Map legacyParameters; - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) EndpointErrorSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") EndpointErrorParameters parameters, - @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { + @JsonProperty("parameters") EndpointErrorParameters parameters) { super(errorCode, errorName, errorInstanceId, parameters); - this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder(); - if (legacyParameters != null) { - builder.putAllParameters(legacyParameters); - } else { - builder.putParameters("typeName", Objects.toString(parameters().typeName())) - .putParameters("typeDef", Objects.toString(parameters().typeDef())); - } - builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); - return builder.build(); + return SerializableError.builder() + .putParameters("typeName", Objects.toString(parameters().typeName())) + .putParameters("typeDef", Objects.toString(parameters().typeDef())) + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()) + .build(); } } diff --git a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/EndpointSpecificTwoErrors.java b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/EndpointSpecificTwoErrors.java index 1679b6e8d..aa010eaea 100644 --- a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/EndpointSpecificTwoErrors.java +++ b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/EndpointSpecificTwoErrors.java @@ -8,8 +8,6 @@ import com.palantir.conjure.java.api.errors.SerializableError; import com.palantir.logsafe.Preconditions; import com.palantir.logsafe.Safe; -import java.util.Map; -import javax.annotation.Nullable; import javax.annotation.processing.Generated; @Generated("com.palantir.conjure.java.types.ErrorGenerator") @@ -30,28 +28,21 @@ public static record DifferentNamespaceParameters() {} public static final class DifferentNamespaceSerializableError extends AbstractSerializableError { - @Nullable - private final Map legacyParameters; - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) DifferentNamespaceSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") DifferentNamespaceParameters parameters, - @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { + @JsonProperty("parameters") DifferentNamespaceParameters parameters) { super(errorCode, errorName, errorInstanceId, parameters); - this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder(); - if (legacyParameters != null) { - builder.putAllParameters(legacyParameters); - } else { - } - builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); - return builder.build(); + return SerializableError.builder() + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()) + .build(); } } diff --git a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/TestErrors.java b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/TestErrors.java index ff98891f0..0fbc0db70 100644 --- a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/TestErrors.java +++ b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/TestErrors.java @@ -11,7 +11,6 @@ import com.palantir.logsafe.Unsafe; import java.util.Map; import java.util.Objects; -import javax.annotation.Nullable; import javax.annotation.processing.Generated; @Generated("com.palantir.conjure.java.types.ErrorGenerator") @@ -54,86 +53,66 @@ public static record NotFoundParameters(@JsonProperty("resource") @Safe String r public static final class ComplicatedParametersSerializableError extends AbstractSerializableError { - @Nullable - private final Map legacyParameters; - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) ComplicatedParametersSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") ComplicatedParametersParameters parameters, - @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { + @JsonProperty("parameters") ComplicatedParametersParameters parameters) { super(errorCode, errorName, errorInstanceId, parameters); - this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder(); - if (legacyParameters != null) { - builder.putAllParameters(legacyParameters); - } else { - builder.putParameters( - "complicatedObjectMap", Objects.toString(parameters().complicatedObjectMap())); - } - builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); - return builder.build(); + return SerializableError.builder() + .putParameters( + "complicatedObjectMap", + Objects.toString(parameters().complicatedObjectMap())) + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()) + .build(); } } public static final class InvalidArgumentSerializableError extends AbstractSerializableError { - @Nullable - private final Map legacyParameters; - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) InvalidArgumentSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") InvalidArgumentParameters parameters, - @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { + @JsonProperty("parameters") InvalidArgumentParameters parameters) { super(errorCode, errorName, errorInstanceId, parameters); - this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder(); - if (legacyParameters != null) { - builder.putAllParameters(legacyParameters); - } else { - builder.putParameters("field", Objects.toString(parameters().field())) - .putParameters("value", Objects.toString(parameters().value())); - } - builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); - return builder.build(); + return SerializableError.builder() + .putParameters("field", Objects.toString(parameters().field())) + .putParameters("value", Objects.toString(parameters().value())) + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()) + .build(); } } public static final class NotFoundSerializableError extends AbstractSerializableError { - @Nullable - private final Map legacyParameters; - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) NotFoundSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") NotFoundParameters parameters, - @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { + @JsonProperty("parameters") NotFoundParameters parameters) { super(errorCode, errorName, errorInstanceId, parameters); - this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder(); - if (legacyParameters != null) { - builder.putAllParameters(legacyParameters); - } else { - builder.putParameters("resource", Objects.toString(parameters().resource())); - } - builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); - return builder.build(); + return SerializableError.builder() + .putParameters("resource", Objects.toString(parameters().resource())) + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()) + .build(); } } diff --git a/conjure-java-core/src/integrationInput/java/errors/com/palantir/another/ConjureErrors.java b/conjure-java-core/src/integrationInput/java/errors/com/palantir/another/ConjureErrors.java index 29040e281..9e2bfa22c 100644 --- a/conjure-java-core/src/integrationInput/java/errors/com/palantir/another/ConjureErrors.java +++ b/conjure-java-core/src/integrationInput/java/errors/com/palantir/another/ConjureErrors.java @@ -9,7 +9,6 @@ import com.palantir.conjure.java.api.errors.ServiceException; import com.palantir.logsafe.Preconditions; import com.palantir.logsafe.Safe; -import java.util.Map; import javax.annotation.Nullable; import javax.annotation.processing.Generated; import org.jetbrains.annotations.Contract; @@ -48,44 +47,37 @@ public static boolean isDifferentPackageError(RemoteException remoteException) { return DIFFERENT_PACKAGE_ERROR.name().equals(remoteException.getError().errorName()); } - public static record DifferentPackageErrParameters() {} - - public static final class DifferentPackageErrSerializableError - extends AbstractSerializableError { - @Nullable - private final Map legacyParameters; + public static record DifferentPackageErrorParameters() {} + public static final class DifferentPackageErrorSerializableError + extends AbstractSerializableError { @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - DifferentPackageErrSerializableError( + DifferentPackageErrorSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") DifferentPackageErrParameters parameters, - @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { + @JsonProperty("parameters") DifferentPackageErrorParameters parameters) { super(errorCode, errorName, errorInstanceId, parameters); - this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder(); - if (legacyParameters != null) { - builder.putAllParameters(legacyParameters); - } else { - } - builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); - return builder.build(); + return SerializableError.builder() + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()) + .build(); } } - public static final class DifferentPackageErrException extends RemoteException { - private DifferentPackageErrSerializableError error; + public static final class DifferentPackageErrorException extends RemoteException { + private DifferentPackageErrorSerializableError error; - public DifferentPackageErrException(DifferentPackageErrSerializableError error, int status) { + public DifferentPackageErrorException(DifferentPackageErrorSerializableError error, int status) { super(error.toSerializableError(), status); this.error = error; } - public DifferentPackageErrSerializableError error() { + public DifferentPackageErrorSerializableError error() { return error; } } diff --git a/conjure-java-core/src/integrationInput/java/errors/com/palantir/another/ConjureJavaOtherErrors.java b/conjure-java-core/src/integrationInput/java/errors/com/palantir/another/ConjureJavaOtherErrors.java index 992d77a23..c85e1c731 100644 --- a/conjure-java-core/src/integrationInput/java/errors/com/palantir/another/ConjureJavaOtherErrors.java +++ b/conjure-java-core/src/integrationInput/java/errors/com/palantir/another/ConjureJavaOtherErrors.java @@ -9,7 +9,6 @@ import com.palantir.conjure.java.api.errors.ServiceException; import com.palantir.logsafe.Preconditions; import com.palantir.logsafe.Safe; -import java.util.Map; import javax.annotation.Nullable; import javax.annotation.processing.Generated; import org.jetbrains.annotations.Contract; @@ -52,28 +51,21 @@ public static record JavaCompilationFailedParameters() {} public static final class JavaCompilationFailedSerializableError extends AbstractSerializableError { - @Nullable - private final Map legacyParameters; - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) JavaCompilationFailedSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") JavaCompilationFailedParameters parameters, - @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { + @JsonProperty("parameters") JavaCompilationFailedParameters parameters) { super(errorCode, errorName, errorInstanceId, parameters); - this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder(); - if (legacyParameters != null) { - builder.putAllParameters(legacyParameters); - } else { - } - builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); - return builder.build(); + return SerializableError.builder() + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()) + .build(); } } diff --git a/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureErrors.java b/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureErrors.java index 339c74287..2037b9e2f 100644 --- a/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureErrors.java +++ b/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureErrors.java @@ -12,7 +12,6 @@ import com.palantir.logsafe.SafeArg; import com.palantir.logsafe.Unsafe; import com.palantir.logsafe.UnsafeArg; -import java.util.Map; import java.util.Objects; import javax.annotation.Nullable; import javax.annotation.processing.Generated; @@ -27,7 +26,7 @@ public final class ConjureErrors { /** Cause argument conflicts with reserved Throwable cause parameter. */ public static final ErrorType CONFLICTING_CAUSE_UNSAFE_ARG = ErrorType.create(ErrorType.Code.INTERNAL, "Conjure:ConflictingCauseUnsafeArg"); - /** Error with complex arguments. */ + public static final ErrorType ERROR_WITH_COMPLEX_ARGS = ErrorType.create(ErrorType.Code.INTERNAL, "Conjure:ErrorWithComplexArgs"); @@ -374,183 +373,136 @@ public static record InvalidTypeDefinitionParameters( public static final class ConflictingCauseSafeArgSerializableError extends AbstractSerializableError { - @Nullable - private final Map legacyParameters; - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) ConflictingCauseSafeArgSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") ConflictingCauseSafeArgParameters parameters, - @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { + @JsonProperty("parameters") ConflictingCauseSafeArgParameters parameters) { super(errorCode, errorName, errorInstanceId, parameters); - this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder(); - if (legacyParameters != null) { - builder.putAllParameters(legacyParameters); - } else { - builder.putParameters("cause", Objects.toString(parameters().cause_())) - .putParameters( - "shouldThrow", Objects.toString(parameters().shouldThrow_())); - } - builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); - return builder.build(); + return SerializableError.builder() + .putParameters("cause", Objects.toString(parameters().cause_())) + .putParameters("shouldThrow", Objects.toString(parameters().shouldThrow_())) + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()) + .build(); } } public static final class ConflictingCauseUnsafeArgSerializableError extends AbstractSerializableError { - @Nullable - private final Map legacyParameters; - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) ConflictingCauseUnsafeArgSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") ConflictingCauseUnsafeArgParameters parameters, - @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { + @JsonProperty("parameters") ConflictingCauseUnsafeArgParameters parameters) { super(errorCode, errorName, errorInstanceId, parameters); - this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder(); - if (legacyParameters != null) { - builder.putAllParameters(legacyParameters); - } else { - builder.putParameters("cause", Objects.toString(parameters().cause_())) - .putParameters( - "shouldThrow", Objects.toString(parameters().shouldThrow_())); - } - builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); - return builder.build(); + return SerializableError.builder() + .putParameters("cause", Objects.toString(parameters().cause_())) + .putParameters("shouldThrow", Objects.toString(parameters().shouldThrow_())) + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()) + .build(); } } public static final class ErrorWithComplexArgsSerializableError extends AbstractSerializableError { - @Nullable - private final Map legacyParameters; - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) ErrorWithComplexArgsSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") ErrorWithComplexArgsParameters parameters, - @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { + @JsonProperty("parameters") ErrorWithComplexArgsParameters parameters) { super(errorCode, errorName, errorInstanceId, parameters); - this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder(); - if (legacyParameters != null) { - builder.putAllParameters(legacyParameters); - } else { - builder.putParameters( - "primitiveExample", - Objects.toString(parameters().primitiveExample())) - .putParameters( - "collectionExample", - Objects.toString(parameters().collectionExample())) - .putParameters( - "nestedCollectionExample", - Objects.toString(parameters().nestedCollectionExample())) - .putParameters( - "optionalExample", Objects.toString(parameters().optionalExample())) - .putParameters( - "objectReference", Objects.toString(parameters().objectReference())) - .putParameters( - "unionExample", Objects.toString(parameters().unionExample())) - .putParameters( - "enumExample", Objects.toString(parameters().enumExample())) - .putParameters( - "stringAlias", Objects.toString(parameters().stringAlias())) - .putParameters( - "optionalAlias", Objects.toString(parameters().optionalAlias())) - .putParameters( - "collectionAlias", Objects.toString(parameters().collectionAlias())) - .putParameters( - "nestedAlias", Objects.toString(parameters().nestedAlias())) - .putParameters( - "externalExample", Objects.toString(parameters().externalExample())) - .putParameters( - "anyExample", Objects.toString(parameters().anyExample())) - .putParameters( - "emptyObject", Objects.toString(parameters().emptyObject())) - .putParameters( - "complexExample", Objects.toString(parameters().complexExample())) - .putParameters( - "safetyExample", Objects.toString(parameters().safetyExample())); - } - builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); - return builder.build(); + return SerializableError.builder() + .putParameters( + "primitiveExample", Objects.toString(parameters().primitiveExample())) + .putParameters( + "collectionExample", Objects.toString(parameters().collectionExample())) + .putParameters( + "nestedCollectionExample", + Objects.toString(parameters().nestedCollectionExample())) + .putParameters( + "optionalExample", Objects.toString(parameters().optionalExample())) + .putParameters( + "objectReference", Objects.toString(parameters().objectReference())) + .putParameters("unionExample", Objects.toString(parameters().unionExample())) + .putParameters("enumExample", Objects.toString(parameters().enumExample())) + .putParameters("stringAlias", Objects.toString(parameters().stringAlias())) + .putParameters( + "optionalAlias", Objects.toString(parameters().optionalAlias())) + .putParameters( + "collectionAlias", Objects.toString(parameters().collectionAlias())) + .putParameters("nestedAlias", Objects.toString(parameters().nestedAlias())) + .putParameters( + "externalExample", Objects.toString(parameters().externalExample())) + .putParameters("anyExample", Objects.toString(parameters().anyExample())) + .putParameters("emptyObject", Objects.toString(parameters().emptyObject())) + .putParameters( + "complexExample", Objects.toString(parameters().complexExample())) + .putParameters( + "safetyExample", Objects.toString(parameters().safetyExample())) + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()) + .build(); } } public static final class InvalidServiceDefinitionSerializableError extends AbstractSerializableError { - @Nullable - private final Map legacyParameters; - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) InvalidServiceDefinitionSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") InvalidServiceDefinitionParameters parameters, - @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { + @JsonProperty("parameters") InvalidServiceDefinitionParameters parameters) { super(errorCode, errorName, errorInstanceId, parameters); - this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder(); - if (legacyParameters != null) { - builder.putAllParameters(legacyParameters); - } else { - builder.putParameters( - "serviceName", Objects.toString(parameters().serviceName())) - .putParameters( - "serviceDef", Objects.toString(parameters().serviceDef())); - } - builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); - return builder.build(); + return SerializableError.builder() + .putParameters("serviceName", Objects.toString(parameters().serviceName())) + .putParameters("serviceDef", Objects.toString(parameters().serviceDef())) + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()) + .build(); } } public static final class InvalidTypeDefinitionSerializableError extends AbstractSerializableError { - @Nullable - private final Map legacyParameters; - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) InvalidTypeDefinitionSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") InvalidTypeDefinitionParameters parameters, - @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { + @JsonProperty("parameters") InvalidTypeDefinitionParameters parameters) { super(errorCode, errorName, errorInstanceId, parameters); - this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder(); - if (legacyParameters != null) { - builder.putAllParameters(legacyParameters); - } else { - builder.putParameters("typeName", Objects.toString(parameters().typeName())) - .putParameters("typeDef", Objects.toString(parameters().typeDef())); - } - builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); - return builder.build(); + return SerializableError.builder() + .putParameters("typeName", Objects.toString(parameters().typeName())) + .putParameters("typeDef", Objects.toString(parameters().typeDef())) + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()) + .build(); } } diff --git a/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureJavaErrors.java b/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureJavaErrors.java index bbff42054..852719463 100644 --- a/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureJavaErrors.java +++ b/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureJavaErrors.java @@ -9,7 +9,6 @@ import com.palantir.conjure.java.api.errors.ServiceException; import com.palantir.logsafe.Preconditions; import com.palantir.logsafe.Safe; -import java.util.Map; import javax.annotation.Nullable; import javax.annotation.processing.Generated; import org.jetbrains.annotations.Contract; @@ -52,28 +51,21 @@ public static record JavaCompilationFailedParameters() {} public static final class JavaCompilationFailedSerializableError extends AbstractSerializableError { - @Nullable - private final Map legacyParameters; - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) JavaCompilationFailedSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") JavaCompilationFailedParameters parameters, - @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { + @JsonProperty("parameters") JavaCompilationFailedParameters parameters) { super(errorCode, errorName, errorInstanceId, parameters); - this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder(); - if (legacyParameters != null) { - builder.putAllParameters(legacyParameters); - } else { - } - builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); - return builder.build(); + return SerializableError.builder() + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()) + .build(); } } diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/another/EndpointSpecificErrors.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/another/EndpointSpecificErrors.java index 1716b4f30..0082660cf 100644 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/another/EndpointSpecificErrors.java +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/another/EndpointSpecificErrors.java @@ -8,8 +8,6 @@ import com.palantir.conjure.java.api.errors.SerializableError; import com.palantir.logsafe.Preconditions; import com.palantir.logsafe.Safe; -import java.util.Map; -import javax.annotation.Nullable; import javax.annotation.processing.Generated; @Generated("com.palantir.conjure.java.types.ErrorGenerator") @@ -30,28 +28,21 @@ public static record DifferentPackageParameters() {} public static final class DifferentPackageSerializableError extends AbstractSerializableError { - @Nullable - private final Map legacyParameters; - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) DifferentPackageSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") DifferentPackageParameters parameters, - @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { + @JsonProperty("parameters") DifferentPackageParameters parameters) { super(errorCode, errorName, errorInstanceId, parameters); - this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder(); - if (legacyParameters != null) { - builder.putAllParameters(legacyParameters); - } else { - } - builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); - return builder.build(); + return SerializableError.builder() + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()) + .build(); } } diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ConjureErrors.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ConjureErrors.java index b48168995..6c87b69b2 100644 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ConjureErrors.java +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ConjureErrors.java @@ -8,9 +8,7 @@ import com.palantir.conjure.java.api.errors.SerializableError; import com.palantir.logsafe.Preconditions; import com.palantir.logsafe.Safe; -import java.util.Map; import java.util.Objects; -import javax.annotation.Nullable; import javax.annotation.processing.Generated; @Generated("com.palantir.conjure.java.types.ErrorGenerator") @@ -34,31 +32,23 @@ public static record ConflictingCauseSafeArgErrParameters( public static final class ConflictingCauseSafeArgErrSerializableError extends AbstractSerializableError { - @Nullable - private final Map legacyParameters; - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) ConflictingCauseSafeArgErrSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") ConflictingCauseSafeArgErrParameters parameters, - @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { + @JsonProperty("parameters") ConflictingCauseSafeArgErrParameters parameters) { super(errorCode, errorName, errorInstanceId, parameters); - this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder(); - if (legacyParameters != null) { - builder.putAllParameters(legacyParameters); - } else { - builder.putParameters("cause", Objects.toString(parameters().cause_())) - .putParameters( - "shouldThrow", Objects.toString(parameters().shouldThrow_())); - } - builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); - return builder.build(); + return SerializableError.builder() + .putParameters("cause", Objects.toString(parameters().cause_())) + .putParameters("shouldThrow", Objects.toString(parameters().shouldThrow_())) + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()) + .build(); } } diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EndpointSpecificErrors.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EndpointSpecificErrors.java index 7754a042b..a39c6e6dc 100644 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EndpointSpecificErrors.java +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EndpointSpecificErrors.java @@ -9,9 +9,7 @@ import com.palantir.logsafe.Preconditions; import com.palantir.logsafe.Safe; import com.palantir.logsafe.Unsafe; -import java.util.Map; import java.util.Objects; -import javax.annotation.Nullable; import javax.annotation.processing.Generated; @Generated("com.palantir.conjure.java.types.ErrorGenerator") @@ -33,30 +31,23 @@ public static record EndpointErrorParameters( public static final class EndpointErrorSerializableError extends AbstractSerializableError { - @Nullable - private final Map legacyParameters; - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) EndpointErrorSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") EndpointErrorParameters parameters, - @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { + @JsonProperty("parameters") EndpointErrorParameters parameters) { super(errorCode, errorName, errorInstanceId, parameters); - this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder(); - if (legacyParameters != null) { - builder.putAllParameters(legacyParameters); - } else { - builder.putParameters("typeName", Objects.toString(parameters().typeName())) - .putParameters("typeDef", Objects.toString(parameters().typeDef())); - } - builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); - return builder.build(); + return SerializableError.builder() + .putParameters("typeName", Objects.toString(parameters().typeName())) + .putParameters("typeDef", Objects.toString(parameters().typeDef())) + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()) + .build(); } } diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EndpointSpecificTwoErrors.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EndpointSpecificTwoErrors.java index 66fa6ace4..210104a03 100644 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EndpointSpecificTwoErrors.java +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EndpointSpecificTwoErrors.java @@ -8,8 +8,6 @@ import com.palantir.conjure.java.api.errors.SerializableError; import com.palantir.logsafe.Preconditions; import com.palantir.logsafe.Safe; -import java.util.Map; -import javax.annotation.Nullable; import javax.annotation.processing.Generated; @Generated("com.palantir.conjure.java.types.ErrorGenerator") @@ -30,28 +28,21 @@ public static record DifferentNamespaceParameters() {} public static final class DifferentNamespaceSerializableError extends AbstractSerializableError { - @Nullable - private final Map legacyParameters; - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) DifferentNamespaceSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") DifferentNamespaceParameters parameters, - @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { + @JsonProperty("parameters") DifferentNamespaceParameters parameters) { super(errorCode, errorName, errorInstanceId, parameters); - this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder(); - if (legacyParameters != null) { - builder.putAllParameters(legacyParameters); - } else { - } - builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); - return builder.build(); + return SerializableError.builder() + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()) + .build(); } } diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/TestErrors.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/TestErrors.java index ed010d381..d99b2a728 100644 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/TestErrors.java +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/TestErrors.java @@ -11,7 +11,6 @@ import com.palantir.logsafe.Unsafe; import java.util.Map; import java.util.Objects; -import javax.annotation.Nullable; import javax.annotation.processing.Generated; @Generated("com.palantir.conjure.java.types.ErrorGenerator") @@ -54,86 +53,66 @@ public static record NotFoundParameters(@JsonProperty("resource") @Safe String r public static final class ComplicatedParametersSerializableError extends AbstractSerializableError { - @Nullable - private final Map legacyParameters; - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) ComplicatedParametersSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") ComplicatedParametersParameters parameters, - @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { + @JsonProperty("parameters") ComplicatedParametersParameters parameters) { super(errorCode, errorName, errorInstanceId, parameters); - this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder(); - if (legacyParameters != null) { - builder.putAllParameters(legacyParameters); - } else { - builder.putParameters( - "complicatedObjectMap", Objects.toString(parameters().complicatedObjectMap())); - } - builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); - return builder.build(); + return SerializableError.builder() + .putParameters( + "complicatedObjectMap", + Objects.toString(parameters().complicatedObjectMap())) + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()) + .build(); } } public static final class InvalidArgumentSerializableError extends AbstractSerializableError { - @Nullable - private final Map legacyParameters; - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) InvalidArgumentSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") InvalidArgumentParameters parameters, - @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { + @JsonProperty("parameters") InvalidArgumentParameters parameters) { super(errorCode, errorName, errorInstanceId, parameters); - this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder(); - if (legacyParameters != null) { - builder.putAllParameters(legacyParameters); - } else { - builder.putParameters("field", Objects.toString(parameters().field())) - .putParameters("value", Objects.toString(parameters().value())); - } - builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); - return builder.build(); + return SerializableError.builder() + .putParameters("field", Objects.toString(parameters().field())) + .putParameters("value", Objects.toString(parameters().value())) + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()) + .build(); } } public static final class NotFoundSerializableError extends AbstractSerializableError { - @Nullable - private final Map legacyParameters; - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) NotFoundSerializableError( @JsonProperty("errorCode") @Safe String errorCode, @JsonProperty("errorName") @Safe String errorName, @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") NotFoundParameters parameters, - @JsonProperty("legacyParameters") @Nullable Map legacyParameters) { + @JsonProperty("parameters") NotFoundParameters parameters) { super(errorCode, errorName, errorInstanceId, parameters); - this.legacyParameters = legacyParameters; } public SerializableError toSerializableError() { - SerializableError.Builder builder = SerializableError.builder(); - if (legacyParameters != null) { - builder.putAllParameters(legacyParameters); - } else { - builder.putParameters("resource", Objects.toString(parameters().resource())); - } - builder.errorCode(errorCode()).errorName(errorName()).errorInstanceId(errorInstanceId()); - return builder.build(); + return SerializableError.builder() + .putParameters("resource", Objects.toString(parameters().resource())) + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()) + .build(); } } diff --git a/conjure-java-core/src/main/java/com/palantir/conjure/java/types/ErrorGenerator.java b/conjure-java-core/src/main/java/com/palantir/conjure/java/types/ErrorGenerator.java index 55ca71e94..11c5c65ca 100644 --- a/conjure-java-core/src/main/java/com/palantir/conjure/java/types/ErrorGenerator.java +++ b/conjure-java-core/src/main/java/com/palantir/conjure/java/types/ErrorGenerator.java @@ -56,7 +56,6 @@ import java.util.Optional; import java.util.stream.Collectors; import java.util.stream.Stream; -import javax.annotation.Nullable; import javax.lang.model.element.Modifier; public final class ErrorGenerator implements Generator { @@ -257,62 +256,39 @@ private static TypeSpec generateSerializableError(ErrorDefinition errorDefinitio .addMember("value", "$S", "parameters") .build()) .build()) - .addParameter(ParameterSpec.builder( - ParameterizedTypeName.get(Map.class, String.class, String.class), "legacyParameters") - .addAnnotation(AnnotationSpec.builder(JsonProperty.class) - .addMember("value", "$S", "legacyParameters") - .build()) - .addAnnotation(Nullable.class) - .build()) .addStatement("super(errorCode, errorName, errorInstanceId, parameters)") - .addStatement("this.legacyParameters = legacyParameters") .build(); // Create the toSerializableError method MethodSpec.Builder toSerializableErrorBuilder = MethodSpec.methodBuilder("toSerializableError") .addModifiers(Modifier.PUBLIC) .returns(SerializableError.class); - CodeBlock.Builder builder = CodeBlock.builder() - .add("$T builder = $T.builder();", SerializableError.Builder.class, SerializableError.class); - - // If therea are legacy parameters, just use those. - - builder.beginControlFlow("if (legacyParameters != null)") - .addStatement("builder.putAllParameters(legacyParameters)") - .nextControlFlow("else"); + CodeBlock.Builder builder = CodeBlock.builder().add("return $T.builder()", SerializableError.class); // Add all parameters List allArgs = new ArrayList<>(); allArgs.addAll(errorDefinition.getSafeArgs()); allArgs.addAll(errorDefinition.getUnsafeArgs()); - for (int i = 0; i < allArgs.size(); i++) { FieldDefinition field = allArgs.get(i); String fieldName = field.getFieldName().get(); builder.add( - (i == 0 ? "builder" : "") + ".putParameters($S, $T.toString(parameters().$L()))" - + (i == allArgs.size() - 1 ? ";" : ""), + ".putParameters($S, $T.toString(parameters().$L()))", fieldName, Objects.class, JavaNameSanitizer.sanitizeErrorParameterName(fieldName)); } - builder.endControlFlow(); - builder.add("builder.errorCode(errorCode())") + builder.add(".errorCode(errorCode())") .add(".errorName(errorName())") - .add(".errorInstanceId(errorInstanceId());"); + .add(".errorInstanceId(errorInstanceId())") + .add(".build();"); toSerializableErrorBuilder.addCode(builder.build()); - toSerializableErrorBuilder.addStatement("return builder.build()"); // Create the class TypeSpec.Builder classBuilder = TypeSpec.classBuilder(serializableErrorClassName) .addModifiers(Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL) .superclass( ParameterizedTypeName.get(ClassName.get(AbstractSerializableError.class), parametersClassName)) - .addField(FieldSpec.builder( - ParameterizedTypeName.get(Map.class, String.class, String.class), "legacyParameters") - .addModifiers(Modifier.PRIVATE, Modifier.FINAL) - .addAnnotation(Nullable.class) - .build()) .addMethod(constructor) .addMethod(toSerializableErrorBuilder.build()); diff --git a/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowServiceEteTest.java b/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowServiceEteTest.java index 2fe25ee84..1b5752b7f 100644 --- a/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowServiceEteTest.java +++ b/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowServiceEteTest.java @@ -63,9 +63,11 @@ import java.time.ZoneId; import java.time.ZoneOffset; import java.util.Collections; +import java.util.List; import java.util.Map; import java.util.Optional; import java.util.concurrent.ThreadLocalRandom; +import java.util.stream.Collectors; import jersey.com.palantir.product.EmptyPathService; import org.junit.jupiter.api.AfterAll; import org.junit.jupiter.api.BeforeAll; @@ -580,11 +582,9 @@ public void testStringParametersDoNotChangeWhenUsingJsonAndJavaString() { // Get the parameters when we use JSON serialization try { - // The `JSON+JAVA-STRING` header is read by `ConjureExceptions` to change the serialization - // behavior. The `JSON` representation of the parameters is sent in the `parameters` field of the Conjure - // error, and a new field `legacyParameters` is added containing the string representation of the - // parameters. - client.errorParameterSerialization(AuthHeader.valueOf("authHeader"), "JSON+JAVA-STRING"); + // The `JSON` header is read by `ConjureExceptions` to change the serialization behavior. The `JSON` + // representation of the parameters is sent in the `parameters` field of the Conjure error. + client.errorParameterSerialization(AuthHeader.valueOf("authHeader"), "JSON"); } catch (RemoteException e) { // .getError() returns the SerializableError which should contain the legacy parameters sent over the wire. jsonParams = e.getError().parameters(); @@ -595,8 +595,28 @@ public void testStringParametersDoNotChangeWhenUsingJsonAndJavaString() { }); } - // Assert that the two maps contain the same keys and values, logging any differences - assertThat(jsonParams).containsExactlyEntriesOf(toStringParams); + // Assert that the two maps contain the same keys and values, except for the `primitiveExample` and `anyExample` + // keys. Those will differ. + List keysThatDiffer = List.of("primitiveExample", "anyExample"); + assertThat(filterKeys(toStringParams, keysThatDiffer)) + .containsExactlyInAnyOrderEntriesOf(filterKeys(jsonParams, keysThatDiffer)); + + // The representation of bytes differs. + String commonFieldsForPrimitive = + "PrimitiveExample{stringVal: example-string, intVal: 42, longVal: 42, doubleVal: 3.14, " + + "boolVal: true, ridVal: ri.service.instance.folder.object, " + + "uuidVal: aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee, " + + "datetimeVal: -999999999-01-01T00:00+18:00, binaryVal: "; + + assertThat(toStringParams.get("primitiveExample")).isEqualTo(commonFieldsForPrimitive + "Bytes{size: 5}}"); + assertThat(jsonParams.get("primitiveExample")) + .isEqualTo(commonFieldsForPrimitive + "java.nio.HeapByteBuffer[pos=0 lim=5 cap=5]}"); + } + + private static Map filterKeys(Map map, List keysToFilter) { + return map.entrySet().stream() + .filter(entry -> !keysToFilter.contains(entry.getKey())) + .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)); } private static HttpURLConnection openConnectionToTestApi(String path) throws IOException { diff --git a/conjure-java-undertow-runtime/src/main/java/com/palantir/conjure/java/undertow/runtime/ConjureError.java b/conjure-java-undertow-runtime/src/main/java/com/palantir/conjure/java/undertow/runtime/ConjureError.java index 7781849b8..9ac4865a5 100644 --- a/conjure-java-undertow-runtime/src/main/java/com/palantir/conjure/java/undertow/runtime/ConjureError.java +++ b/conjure-java-undertow-runtime/src/main/java/com/palantir/conjure/java/undertow/runtime/ConjureError.java @@ -16,8 +16,6 @@ package com.palantir.conjure.java.undertow.runtime; -import com.fasterxml.jackson.annotation.JsonIgnore; -import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; import com.palantir.conjure.java.api.errors.CheckedServiceException; import com.palantir.conjure.java.api.errors.EndpointServiceException; @@ -58,15 +56,7 @@ record ConjureError( @JsonProperty("errorCode") String errorCode, @JsonProperty("errorName") String errorName, @JsonProperty("errorInstanceId") String errorInstanceId, - @JsonProperty("parameters") Map parameters, - @JsonIgnore Optional> legacyParameters) { - - @JsonProperty("legacyParameters") - // Only populate the legacy parameters field if it is non-empty. - @JsonInclude(JsonInclude.Include.NON_NULL) - Map getLegacyParametersForSerialization() { - return legacyParameters.orElse(null); - } + @JsonProperty("parameters") Map parameters) { ConjureError { Preconditions.checkNotNull(errorCode, "errorCode cannot be null"); @@ -81,8 +71,7 @@ static ConjureError fromCheckedServiceException(CheckedServiceException exceptio exception.getErrorType().code().name(), exception.getErrorType().name(), exception.getErrorInstanceId(), - parameters, - Optional.empty()); + parameters); } static ConjureError fromEndpointServiceException(EndpointServiceException exception) { @@ -91,8 +80,7 @@ static ConjureError fromEndpointServiceException(EndpointServiceException except exception.getErrorType().code().name(), exception.getErrorType().name(), exception.getErrorInstanceId(), - parameters, - Optional.empty()); + parameters); } static ConjureError fromServiceException(ServiceException exception) { @@ -101,12 +89,7 @@ static ConjureError fromServiceException(ServiceException exception) { parameters.put(arg.getName(), Objects.toString(arg.getValue())); } ErrorType errorType = exception.getErrorType(); - return new ConjureError( - errorType.code().name(), - errorType.name(), - exception.getErrorInstanceId(), - parameters, - Optional.empty()); + return new ConjureError(errorType.code().name(), errorType.name(), exception.getErrorInstanceId(), parameters); } /** @@ -117,27 +100,7 @@ static ConjureError fromServiceException(ServiceException exception) { static ConjureError fromServiceExceptionWithJsonSerializedParameterValues(ServiceException exception) { Map parameters = getParametersFromArgs(exception.getArgs()); ErrorType errorType = exception.getErrorType(); - return new ConjureError( - errorType.code().name(), - errorType.name(), - exception.getErrorInstanceId(), - parameters, - Optional.empty()); - } - - static ConjureError fromServiceExceptionWithJsonAndJavaStringSerializedParameterValues(ServiceException exception) { - Map parameters = getParametersFromArgs(exception.getArgs()); - Map legacyParameters = new HashMap<>(); - for (Arg arg : exception.getArgs()) { - legacyParameters.put(arg.getName(), Objects.toString(arg.getValue())); - } - ErrorType errorType = exception.getErrorType(); - return new ConjureError( - errorType.code().name(), - errorType.name(), - exception.getErrorInstanceId(), - parameters, - Optional.of(legacyParameters)); + return new ConjureError(errorType.code().name(), errorType.name(), exception.getErrorInstanceId(), parameters); } /** @@ -149,12 +112,7 @@ static ConjureError fromServiceExceptionWithJsonAndJavaStringSerializedParameter */ static ConjureError fromRemoteException(RemoteException exception) { SerializableError error = exception.getError(); - return new ConjureError( - error.errorCode(), - error.errorName(), - error.errorInstanceId(), - Collections.emptyMap(), - Optional.empty()); + return new ConjureError(error.errorCode(), error.errorName(), error.errorInstanceId(), Collections.emptyMap()); } private static boolean shouldIncludeArgInParameters(Arg arg) { diff --git a/conjure-java-undertow-runtime/src/main/java/com/palantir/conjure/java/undertow/runtime/ConjureExceptions.java b/conjure-java-undertow-runtime/src/main/java/com/palantir/conjure/java/undertow/runtime/ConjureExceptions.java index 3a90da4c1..5a40505ed 100644 --- a/conjure-java-undertow-runtime/src/main/java/com/palantir/conjure/java/undertow/runtime/ConjureExceptions.java +++ b/conjure-java-undertow-runtime/src/main/java/com/palantir/conjure/java/undertow/runtime/ConjureExceptions.java @@ -130,32 +130,18 @@ private static void serviceException(HttpServerExchange exchange, ServiceExcepti .toString() .equalsIgnoreCase(ConjureErrorParameterFormat.JSON_FORMAT.toString()); - boolean isJsonStringErrorParameterValueFormat = isHeaderPresent - && maybeErrorParamFormatHeader - .get() - .toString() - .equalsIgnoreCase(ConjureErrorParameterFormat.JSON_AND_JAVA_STRING_FORMAT.toString()); - // Log unrecognized format if present but not JSON - if (isHeaderPresent && !isJsonErrorParameterValueFormat && !isJsonStringErrorParameterValueFormat) { + if (isHeaderPresent && !isJsonErrorParameterValueFormat) { log.info( "Unrecognized Conjure error parameter format header", SafeArg.of("headerValue", maybeErrorParamFormatHeader.get())); } // Use the appropriate serialization based on format - - ConjureError conjureError; - if (isJsonErrorParameterValueFormat) { - logWithSerializationFormat(exception, Optional.of(ConjureErrorParameterFormat.JSON_FORMAT)); - conjureError = ConjureError.fromServiceExceptionWithJsonSerializedParameterValues(exception); - } else if (isJsonStringErrorParameterValueFormat) { - logWithSerializationFormat(exception, Optional.of(ConjureErrorParameterFormat.JSON_AND_JAVA_STRING_FORMAT)); - conjureError = ConjureError.fromServiceExceptionWithJsonAndJavaStringSerializedParameterValues(exception); - } else { - logWithSerializationFormat(exception, Optional.empty()); - conjureError = ConjureError.fromServiceException(exception); - } + logWithSerializationFormat(exception, isJsonErrorParameterValueFormat); + ConjureError conjureError = isJsonErrorParameterValueFormat + ? ConjureError.fromServiceExceptionWithJsonSerializedParameterValues(exception) + : ConjureError.fromServiceException(exception); writeResponse( exchange, Optional.of(conjureError), exception.getErrorType().httpErrorCode()); @@ -304,20 +290,20 @@ private static boolean isResponseStarted(HttpServerExchange exchange) { } private static void logWithSerializationFormat( - ServiceException serviceException, Optional parameterFormat) { + ServiceException serviceException, boolean isUsingJsonSerializationForParameters) { if (serviceException.getErrorType().httpErrorCode() / 100 == 4 /* client error */) { log.info( "Error handling request", SafeArg.of("errorInstanceId", serviceException.getErrorInstanceId()), SafeArg.of("errorName", serviceException.getErrorType().name()), - SafeArg.of("parameterFormat", parameterFormat), + SafeArg.of("isUsingJsonSerializationForParameters", isUsingJsonSerializationForParameters), serviceException); } else { log.error( "Error handling request", SafeArg.of("errorInstanceId", serviceException.getErrorInstanceId()), SafeArg.of("errorName", serviceException.getErrorType().name()), - SafeArg.of("parameterFormat", parameterFormat), + SafeArg.of("isUsingJsonSerializationForParameters", isUsingJsonSerializationForParameters), serviceException); } } From 9ddc9271e8cd478cc55526c70d0e2c32c47fa760 Mon Sep 17 00:00:00 2001 From: Pritham Marupaka Date: Tue, 19 Aug 2025 11:21:13 -0400 Subject: [PATCH 16/26] remove unneeded check for 'bodySerDe.errorParameterFormat' --- .../product/EmptyPathServiceAsync.java | 7 +- .../product/EmptyPathServiceBlocking.java | 7 +- .../product/EteBinaryServiceAsync.java | 42 +--- .../product/EteBinaryServiceBlocking.java | 42 +--- .../com/palantir/product/EteServiceAsync.java | 231 +++++------------- .../palantir/product/EteServiceBlocking.java | 231 +++++------------- .../dialogue/test/api/CookieServiceAsync.java | 7 +- .../test/api/CookieServiceBlocking.java | 7 +- .../palantir/product/ErrorServiceAsync.java | 48 ---- .../product/ErrorServiceBlocking.java | 48 ---- .../palantir/another/TestServiceBlocking.java | 176 ------------- .../ServiceUsingExternalTypesAsync.java | 8 - .../ServiceUsingExternalTypesBlocking.java | 8 - .../palantir/another/TestServiceAsync.java | 176 ------------- .../palantir/another/TestServiceBlocking.java | 176 ------------- .../test/api/CookieServiceAsync.java | 8 - .../test/api/CookieServiceBlocking.java | 8 - .../DefaultStaticFactoryMethodGenerator.java | 25 +- versions.lock | 6 +- versions.props | 2 +- 20 files changed, 181 insertions(+), 1082 deletions(-) diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceAsync.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceAsync.java index db77bb559..463bc4d1c 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceAsync.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceAsync.java @@ -70,13 +70,10 @@ private ExceptionDeserializerArgs createExceptionDeserializerArgs(TypeMar @Override public ListenableFuture emptyPath() { Request.Builder _request = Request.builder(); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients().call(emptyPathChannel, _request.build(), emptyPathDeserializer); } diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceBlocking.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceBlocking.java index 203262d5a..ae1deb4bc 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceBlocking.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceBlocking.java @@ -69,13 +69,10 @@ private ExceptionDeserializerArgs createExceptionDeserializerArgs(TypeMar @Override public boolean emptyPath() { Request.Builder _request = Request.builder(); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients().callBlocking(emptyPathChannel, _request.build(), emptyPathDeserializer); } diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceAsync.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceAsync.java index ef0f1fb0c..42823d245 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceAsync.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceAsync.java @@ -133,13 +133,10 @@ public ListenableFuture postBinary(AuthHeader authHeader, BinaryReq Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(_runtime.bodySerDe().serialize(body)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients().call(postBinaryChannel, _request.build(), postBinaryDeserializer); } @@ -151,13 +148,10 @@ public ListenableFuture postBinaryThrows( _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(_runtime.bodySerDe().serialize(body)); _request.putQueryParams("bytesToRead", _plainSerDe.serializeInteger(bytesToRead)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients().call(postBinaryThrowsChannel, _request.build(), postBinaryThrowsDeserializer); } @@ -166,13 +160,10 @@ public ListenableFuture postBinaryThrows( public ListenableFuture> getOptionalBinaryPresent(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients() .call(getOptionalBinaryPresentChannel, _request.build(), getOptionalBinaryPresentDeserializer); @@ -182,13 +173,10 @@ public ListenableFuture> getOptionalBinaryPresent(AuthHead public ListenableFuture> getOptionalBinaryEmpty(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients() .call(getOptionalBinaryEmptyChannel, _request.build(), getOptionalBinaryEmptyDeserializer); @@ -201,13 +189,10 @@ public ListenableFuture getBinaryFailure( _request.putHeaderParams("Authorization", authHeader.toString()); _request.putQueryParams("numBytes", _plainSerDe.serializeInteger(numBytes)); _request.putQueryParams("useTryWithResources", _plainSerDe.serializeBoolean(useTryWithResources)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients().call(getBinaryFailureChannel, _request.build(), getBinaryFailureDeserializer); } @@ -216,13 +201,10 @@ public ListenableFuture getBinaryFailure( public ListenableFuture> getAliased(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients().call(getAliasedChannel, _request.build(), getAliasedDeserializer); } diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceBlocking.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceBlocking.java index 89e2af16b..7ca026b1b 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceBlocking.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceBlocking.java @@ -136,13 +136,10 @@ public InputStream postBinary(AuthHeader authHeader, BinaryRequestBody body) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(_runtime.bodySerDe().serialize(body)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients().callBlocking(postBinaryChannel, _request.build(), postBinaryDeserializer); } @@ -153,13 +150,10 @@ public InputStream postBinaryThrows(AuthHeader authHeader, int bytesToRead, Bina _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(_runtime.bodySerDe().serialize(body)); _request.putQueryParams("bytesToRead", _plainSerDe.serializeInteger(bytesToRead)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients() .callBlocking(postBinaryThrowsChannel, _request.build(), postBinaryThrowsDeserializer); @@ -169,13 +163,10 @@ public InputStream postBinaryThrows(AuthHeader authHeader, int bytesToRead, Bina public Optional getOptionalBinaryPresent(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients() .callBlocking( @@ -188,13 +179,10 @@ public Optional getOptionalBinaryPresent(AuthHeader authHeader) { public Optional getOptionalBinaryEmpty(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients() .callBlocking( @@ -207,13 +195,10 @@ public InputStream getBinaryFailure(AuthHeader authHeader, int numBytes, boolean _request.putHeaderParams("Authorization", authHeader.toString()); _request.putQueryParams("numBytes", _plainSerDe.serializeInteger(numBytes)); _request.putQueryParams("useTryWithResources", _plainSerDe.serializeBoolean(useTryWithResources)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients() .callBlocking(getBinaryFailureChannel, _request.build(), getBinaryFailureDeserializer); @@ -223,13 +208,10 @@ public InputStream getBinaryFailure(AuthHeader authHeader, int numBytes, boolean public Optional getAliased(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients().callBlocking(getAliasedChannel, _request.build(), getAliasedDeserializer); } diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceAsync.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceAsync.java index a900c7767..b60d0e56c 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceAsync.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceAsync.java @@ -474,13 +474,10 @@ private ExceptionDeserializerArgs createExceptionDeserializerArgs(TypeMar public ListenableFuture string(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients().call(stringChannel, _request.build(), stringDeserializer); } @@ -489,13 +486,10 @@ public ListenableFuture string(AuthHeader authHeader) { public ListenableFuture integer(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients().call(integerChannel, _request.build(), integerDeserializer); } @@ -504,13 +498,10 @@ public ListenableFuture integer(AuthHeader authHeader) { public ListenableFuture double_(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients().call(double_Channel, _request.build(), double_Deserializer); } @@ -519,13 +510,10 @@ public ListenableFuture double_(AuthHeader authHeader) { public ListenableFuture boolean_(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients().call(boolean_Channel, _request.build(), boolean_Deserializer); } @@ -534,13 +522,10 @@ public ListenableFuture boolean_(AuthHeader authHeader) { public ListenableFuture safelong(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients().call(safelongChannel, _request.build(), safelongDeserializer); } @@ -549,13 +534,10 @@ public ListenableFuture safelong(AuthHeader authHeader) { public ListenableFuture rid(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients().call(ridChannel, _request.build(), ridDeserializer); } @@ -564,13 +546,10 @@ public ListenableFuture rid(AuthHeader authHeader) { public ListenableFuture bearertoken(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients().call(bearertokenChannel, _request.build(), bearertokenDeserializer); } @@ -579,13 +558,10 @@ public ListenableFuture bearertoken(AuthHeader authHeader) { public ListenableFuture> optionalString(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients().call(optionalStringChannel, _request.build(), optionalStringDeserializer); } @@ -594,13 +570,10 @@ public ListenableFuture> optionalString(AuthHeader authHeader) public ListenableFuture> optionalEmpty(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients().call(optionalEmptyChannel, _request.build(), optionalEmptyDeserializer); } @@ -609,13 +582,10 @@ public ListenableFuture> optionalEmpty(AuthHeader authHeader) { public ListenableFuture datetime(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients().call(datetimeChannel, _request.build(), datetimeDeserializer); } @@ -624,13 +594,10 @@ public ListenableFuture datetime(AuthHeader authHeader) { public ListenableFuture binary(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients().call(binaryChannel, _request.build(), binaryDeserializer); } @@ -640,13 +607,10 @@ public ListenableFuture path(AuthHeader authHeader, String param) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("param", _plainSerDe.serializeString(param)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients().call(pathChannel, _request.build(), pathDeserializer); } @@ -656,13 +620,10 @@ public ListenableFuture externalLongPath(AuthHeader authHeader, long param Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("param", Objects.toString(param)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients().call(externalLongPathChannel, _request.build(), externalLongPathDeserializer); } @@ -675,13 +636,10 @@ public ListenableFuture> optionalExternalLongQuery( if (param.isPresent()) { _request.putQueryParams("param", Objects.toString(param.get())); } - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients() .call( @@ -696,13 +654,10 @@ public ListenableFuture notNullBody( Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(notNullBodySerializer.serialize(notNullBody)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients().call(notNullBodyChannel, _request.build(), notNullBodyDeserializer); } @@ -713,13 +668,10 @@ public ListenableFuture aliasOne( Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putQueryParams("queryParamName", _plainSerDe.serializeString(queryParamName.get())); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients().call(aliasOneChannel, _request.build(), aliasOneDeserializer); } @@ -734,13 +686,10 @@ public ListenableFuture optionalAliasOne( "queryParamName", _plainSerDe.serializeString(queryParamName.get().get())); } - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients().call(optionalAliasOneChannel, _request.build(), optionalAliasOneDeserializer); } @@ -753,13 +702,10 @@ public ListenableFuture aliasTwo( _request.putQueryParams( "queryParamName", _plainSerDe.serializeString(queryParamName.get().get())); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients().call(aliasTwoChannel, _request.build(), aliasTwoDeserializer); } @@ -770,13 +716,10 @@ public ListenableFuture not Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(notNullBodyExternalImportSerializer.serialize(notNullBody)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients() .call( @@ -792,13 +735,10 @@ public ListenableFuture not Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(optionalBodyExternalImportSerializer.serialize(body)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients() .call( @@ -817,13 +757,10 @@ public ListenableFuture not if (query.isPresent()) { _request.putQueryParams("query", Objects.toString(query.get())); } - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients() .call( @@ -836,13 +773,10 @@ public ListenableFuture not public ListenableFuture noReturn(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients().call(noReturnChannel, _request.build(), noReturnDeserializer); } @@ -852,13 +786,10 @@ public ListenableFuture enumQuery(AuthHeader authHeader, SimpleEnum Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putQueryParams("queryParamName", Objects.toString(queryParamName)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients().call(enumQueryChannel, _request.build(), enumQueryDeserializer); } @@ -871,13 +802,10 @@ public ListenableFuture> enumListQuery( for (SimpleEnum queryParamNameElement : queryParamName) { _request.putQueryParams("queryParamName", Objects.toString(queryParamNameElement)); } - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients().call(enumListQueryChannel, _request.build(), enumListQueryDeserializer); } @@ -890,13 +818,10 @@ public ListenableFuture> optionalEnumQuery( if (queryParamName.isPresent()) { _request.putQueryParams("queryParamName", Objects.toString(queryParamName.get())); } - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients() .call(optionalEnumQueryChannel, _request.build(), optionalEnumQueryDeserializer); @@ -907,13 +832,10 @@ public ListenableFuture enumHeader(AuthHeader authHeader, SimpleEnum Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putHeaderParams("Custom-Header", Objects.toString(headerParameter)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients().call(enumHeaderChannel, _request.build(), enumHeaderDeserializer); } @@ -924,13 +846,10 @@ public ListenableFuture jsonErrorsHeader(AuthHeader authHeader, String h _request.putHeaderParams("Authorization", authHeader.toString()); _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", _plainSerDe.serializeString(headerParameter)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients().call(jsonErrorsHeaderChannel, _request.build(), jsonErrorsHeaderDeserializer); } @@ -941,13 +860,10 @@ public ListenableFuture errorParameterSerialization(AuthHeader authHeade _request.putHeaderParams("Authorization", authHeader.toString()); _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", _plainSerDe.serializeString(headerParameter)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients() .call( @@ -965,13 +881,10 @@ public ListenableFuture> aliasLongEndpoint( _request.putQueryParams( "input", Objects.toString(input.get().get())); } - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients() .call(aliasLongEndpointChannel, _request.build(), aliasLongEndpointDeserializer); @@ -996,13 +909,10 @@ public ListenableFuture complexQueryParameters( for (int intsElement : ints) { _request.putQueryParams("ints", _plainSerDe.serializeInteger(intsElement)); } - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients() .call(complexQueryParametersChannel, _request.build(), complexQueryParametersDeserializer); @@ -1013,13 +923,10 @@ public ListenableFuture receiveListOfOptionals(AuthHeader authHeader, List Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(receiveListOfOptionalsSerializer.serialize(value)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients() .call(receiveListOfOptionalsChannel, _request.build(), receiveListOfOptionalsDeserializer); @@ -1030,13 +937,10 @@ public ListenableFuture receiveSetOfOptionals(AuthHeader authHeader, Set receiveListOfStrings(AuthHeader authHeader, List ExceptionDeserializerArgs createExceptionDeserializerArgs(TypeMar public String string(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients().callBlocking(stringChannel, _request.build(), stringDeserializer); } @@ -488,13 +485,10 @@ public String string(AuthHeader authHeader) { public int integer(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients().callBlocking(integerChannel, _request.build(), integerDeserializer); } @@ -503,13 +497,10 @@ public int integer(AuthHeader authHeader) { public double double_(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients().callBlocking(double_Channel, _request.build(), double_Deserializer); } @@ -518,13 +509,10 @@ public double double_(AuthHeader authHeader) { public boolean boolean_(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients().callBlocking(boolean_Channel, _request.build(), boolean_Deserializer); } @@ -533,13 +521,10 @@ public boolean boolean_(AuthHeader authHeader) { public SafeLong safelong(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients().callBlocking(safelongChannel, _request.build(), safelongDeserializer); } @@ -548,13 +533,10 @@ public SafeLong safelong(AuthHeader authHeader) { public ResourceIdentifier rid(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients().callBlocking(ridChannel, _request.build(), ridDeserializer); } @@ -563,13 +545,10 @@ public ResourceIdentifier rid(AuthHeader authHeader) { public BearerToken bearertoken(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients().callBlocking(bearertokenChannel, _request.build(), bearertokenDeserializer); } @@ -578,13 +557,10 @@ public BearerToken bearertoken(AuthHeader authHeader) { public Optional optionalString(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients() .callBlocking(optionalStringChannel, _request.build(), optionalStringDeserializer); @@ -594,13 +570,10 @@ public Optional optionalString(AuthHeader authHeader) { public Optional optionalEmpty(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients() .callBlocking(optionalEmptyChannel, _request.build(), optionalEmptyDeserializer); @@ -610,13 +583,10 @@ public Optional optionalEmpty(AuthHeader authHeader) { public OffsetDateTime datetime(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients().callBlocking(datetimeChannel, _request.build(), datetimeDeserializer); } @@ -625,13 +595,10 @@ public OffsetDateTime datetime(AuthHeader authHeader) { public InputStream binary(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients().callBlocking(binaryChannel, _request.build(), binaryDeserializer); } @@ -641,13 +608,10 @@ public String path(AuthHeader authHeader, String param) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("param", _plainSerDe.serializeString(param)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients().callBlocking(pathChannel, _request.build(), pathDeserializer); } @@ -657,13 +621,10 @@ public long externalLongPath(AuthHeader authHeader, long param) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("param", Objects.toString(param)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients() .callBlocking(externalLongPathChannel, _request.build(), externalLongPathDeserializer); @@ -676,13 +637,10 @@ public Optional optionalExternalLongQuery(AuthHeader authHeader, Optional< if (param.isPresent()) { _request.putQueryParams("param", Objects.toString(param.get())); } - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients() .callBlocking( @@ -696,13 +654,10 @@ public StringAliasExample notNullBody(AuthHeader authHeader, StringAliasExample Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(notNullBodySerializer.serialize(notNullBody)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients().callBlocking(notNullBodyChannel, _request.build(), notNullBodyDeserializer); } @@ -712,13 +667,10 @@ public StringAliasExample aliasOne(AuthHeader authHeader, StringAliasExample que Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putQueryParams("queryParamName", _plainSerDe.serializeString(queryParamName.get())); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients().callBlocking(aliasOneChannel, _request.build(), aliasOneDeserializer); } @@ -733,13 +685,10 @@ public StringAliasExample optionalAliasOne( "queryParamName", _plainSerDe.serializeString(queryParamName.get().get())); } - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients() .callBlocking(optionalAliasOneChannel, _request.build(), optionalAliasOneDeserializer); @@ -752,13 +701,10 @@ public NestedStringAliasExample aliasTwo(AuthHeader authHeader, NestedStringAlia _request.putQueryParams( "queryParamName", _plainSerDe.serializeString(queryParamName.get().get())); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients().callBlocking(aliasTwoChannel, _request.build(), aliasTwoDeserializer); } @@ -769,13 +715,10 @@ public allexamples.com.palantir.product.StringAliasExample notNullBodyExternalIm Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(notNullBodyExternalImportSerializer.serialize(notNullBody)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients() .callBlocking( @@ -790,13 +733,10 @@ public Optional optionalBod Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(optionalBodyExternalImportSerializer.serialize(body)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients() .callBlocking( @@ -813,13 +753,10 @@ public Optional optionalQue if (query.isPresent()) { _request.putQueryParams("query", Objects.toString(query.get())); } - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients() .callBlocking( @@ -832,13 +769,10 @@ public Optional optionalQue public void noReturn(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } _runtime.clients().callBlocking(noReturnChannel, _request.build(), noReturnDeserializer); } @@ -848,13 +782,10 @@ public SimpleEnum enumQuery(AuthHeader authHeader, SimpleEnum queryParamName) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putQueryParams("queryParamName", Objects.toString(queryParamName)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients().callBlocking(enumQueryChannel, _request.build(), enumQueryDeserializer); } @@ -866,13 +797,10 @@ public List enumListQuery(AuthHeader authHeader, List qu for (SimpleEnum queryParamNameElement : queryParamName) { _request.putQueryParams("queryParamName", Objects.toString(queryParamNameElement)); } - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients() .callBlocking(enumListQueryChannel, _request.build(), enumListQueryDeserializer); @@ -885,13 +813,10 @@ public Optional optionalEnumQuery(AuthHeader authHeader, Optional aliasLongEndpoint(AuthHeader authHeader, Optional> Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(receiveListOfOptionalsSerializer.serialize(value)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } _runtime.clients() .callBlocking( @@ -1027,13 +934,10 @@ public void receiveSetOfOptionals(AuthHeader authHeader, Set> v Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(receiveSetOfOptionalsSerializer.serialize(value)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } _runtime.clients() .callBlocking( @@ -1045,13 +949,10 @@ public void receiveListOfStrings(AuthHeader authHeader, List value) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(receiveListOfStringsSerializer.serialize(value)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } _runtime.clients() .callBlocking(receiveListOfStringsChannel, _request.build(), receiveListOfStringsDeserializer); diff --git a/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceAsync.java b/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceAsync.java index d55202085..8e3b7ca3c 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceAsync.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceAsync.java @@ -48,13 +48,10 @@ private ExceptionDeserializerArgs createExceptionDeserializerArgs(TypeMar public ListenableFuture eatCookies(BearerToken token) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Cookie", "PALANTIR_TOKEN=" + _plainSerDe.serializeBearerToken(token)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } return _runtime.clients().call(eatCookiesChannel, _request.build(), eatCookiesDeserializer); } diff --git a/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceBlocking.java b/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceBlocking.java index 78fc39e12..6411b609a 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceBlocking.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceBlocking.java @@ -47,13 +47,10 @@ private ExceptionDeserializerArgs createExceptionDeserializerArgs(TypeMar public void eatCookies(BearerToken token) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Cookie", "PALANTIR_TOKEN=" + _plainSerDe.serializeBearerToken(token)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); + _runtime.bodySerDe().errorParameterFormat().get().toString()); } _runtime.clients().callBlocking(eatCookiesChannel, _request.build(), eatCookiesDeserializer); } diff --git a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorServiceAsync.java b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorServiceAsync.java index ad3ed5ea0..06c57b75c 100644 --- a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorServiceAsync.java +++ b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorServiceAsync.java @@ -189,14 +189,6 @@ public ListenableFuture testBasicError( Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(testBasicErrorSerializer.serialize(shouldThrowError)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients().call(testBasicErrorChannel, _request.build(), testBasicErrorDeserializer); } @@ -206,14 +198,6 @@ public ListenableFuture testImportedError( Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(testImportedErrorSerializer.serialize(shouldThrowError)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients() .call(testImportedErrorChannel, _request.build(), testImportedErrorDeserializer); } @@ -224,14 +208,6 @@ public ListenableFuture testMultipleError Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(testMultipleErrorsAndPackagesSerializer.serialize(errorToThrow)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients() .call( testMultipleErrorsAndPackagesChannel, @@ -245,14 +221,6 @@ public ListenableFuture testEmptyBody( Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(testEmptyBodySerializer.serialize(shouldThrowError)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients().call(testEmptyBodyChannel, _request.build(), testEmptyBodyDeserializer); } @@ -261,14 +229,6 @@ public ListenableFuture testBinary(AuthHeader authHeader, bo Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(testBinarySerializer.serialize(shouldThrowError)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients().call(testBinaryChannel, _request.build(), testBinaryDeserializer); } @@ -278,14 +238,6 @@ public ListenableFuture testOptionalBinary( Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(testOptionalBinarySerializer.serialize(mode)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients() .call(testOptionalBinaryChannel, _request.build(), testOptionalBinaryDeserializer); } diff --git a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorServiceBlocking.java b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorServiceBlocking.java index dd1d6c4ff..056d33312 100644 --- a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorServiceBlocking.java +++ b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorServiceBlocking.java @@ -186,14 +186,6 @@ public TestBasicErrorResponse testBasicError(AuthHeader authHeader, boolean shou Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(testBasicErrorSerializer.serialize(shouldThrowError)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients() .callBlocking(testBasicErrorChannel, _request.build(), testBasicErrorDeserializer); } @@ -203,14 +195,6 @@ public TestImportedErrorResponse testImportedError(AuthHeader authHeader, boolea Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(testImportedErrorSerializer.serialize(shouldThrowError)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients() .callBlocking(testImportedErrorChannel, _request.build(), testImportedErrorDeserializer); } @@ -221,14 +205,6 @@ public TestMultipleErrorsAndPackagesResponse testMultipleErrorsAndPackages( Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(testMultipleErrorsAndPackagesSerializer.serialize(errorToThrow)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients() .callBlocking( testMultipleErrorsAndPackagesChannel, @@ -241,14 +217,6 @@ public TestEmptyBodyResponse testEmptyBody(AuthHeader authHeader, boolean should Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(testEmptyBodySerializer.serialize(shouldThrowError)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients() .callBlocking(testEmptyBodyChannel, _request.build(), testEmptyBodyDeserializer); } @@ -258,14 +226,6 @@ public TestBinaryResponse testBinary(AuthHeader authHeader, boolean shouldThrowE Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(testBinarySerializer.serialize(shouldThrowError)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients().callBlocking(testBinaryChannel, _request.build(), testBinaryDeserializer); } @@ -275,14 +235,6 @@ public TestOptionalBinaryResponse testOptionalBinary( Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(testOptionalBinarySerializer.serialize(mode)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients() .callBlocking(testOptionalBinaryChannel, _request.build(), testOptionalBinaryDeserializer); } diff --git a/conjure-java-core/src/integrationInput/java/excludeasyncinterfaces/com/palantir/another/TestServiceBlocking.java b/conjure-java-core/src/integrationInput/java/excludeasyncinterfaces/com/palantir/another/TestServiceBlocking.java index 1268cb4ed..df308a663 100644 --- a/conjure-java-core/src/integrationInput/java/excludeasyncinterfaces/com/palantir/another/TestServiceBlocking.java +++ b/conjure-java-core/src/integrationInput/java/excludeasyncinterfaces/com/palantir/another/TestServiceBlocking.java @@ -322,14 +322,6 @@ static TestServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Co public Map getFileSystems(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients() .callBlocking(getFileSystemsChannel, _request.build(), getFileSystemsDeserializer); } @@ -340,14 +332,6 @@ public Dataset createDataset(AuthHeader authHeader, String testHeaderArg, Create _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(createDatasetSerializer.serialize(request)); _request.putHeaderParams("Test-Header", _plainSerDe.serializeString(testHeaderArg)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients() .callBlocking(createDatasetChannel, _request.build(), createDatasetDeserializer); } @@ -357,14 +341,6 @@ public Optional getDataset(AuthHeader authHeader, ResourceIdentifier da Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients().callBlocking(getDatasetChannel, _request.build(), getDatasetDeserializer); } @@ -373,14 +349,6 @@ public InputStream getRawData(AuthHeader authHeader, ResourceIdentifier datasetR Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients() .callBlocking( getRawDataChannel, @@ -393,14 +361,6 @@ public InputStream getAliasedRawData(AuthHeader authHeader, ResourceIdentifier d Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients() .callBlocking( getAliasedRawDataChannel, @@ -413,14 +373,6 @@ public Optional maybeGetRawData(AuthHeader authHeader, ResourceIden Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients() .callBlocking( maybeGetRawDataChannel, @@ -433,14 +385,6 @@ public AliasedString getAliasedString(AuthHeader authHeader, ResourceIdentifier Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients() .callBlocking(getAliasedStringChannel, _request.build(), getAliasedStringDeserializer); } @@ -450,14 +394,6 @@ public void uploadRawData(AuthHeader authHeader, BinaryRequestBody input) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(_runtime.bodySerDe().serialize(input)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } _runtime.clients().callBlocking(uploadRawDataChannel, _request.build(), uploadRawDataDeserializer); } @@ -466,14 +402,6 @@ public void uploadAliasedRawData(AuthHeader authHeader, BinaryRequestBody input) Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(_runtime.bodySerDe().serialize(input)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } _runtime.clients() .callBlocking(uploadAliasedRawDataChannel, _request.build(), uploadAliasedRawDataDeserializer); } @@ -483,14 +411,6 @@ public Set getBranches(AuthHeader authHeader, ResourceIdentifier dataset Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients().callBlocking(getBranchesChannel, _request.build(), getBranchesDeserializer); } @@ -500,14 +420,6 @@ public Set getBranchesDeprecated(AuthHeader authHeader, ResourceIdentifi Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients() .callBlocking( getBranchesDeprecatedChannel, _request.build(), getBranchesDeprecatedDeserializer); @@ -519,14 +431,6 @@ public Set getBranchesDeprecatedForRemoval(AuthHeader authHeader, Resour Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients() .callBlocking( getBranchesDeprecatedForRemovalChannel, @@ -540,14 +444,6 @@ public Optional resolveBranch(AuthHeader authHeader, ResourceIdentifier _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); _request.putPathParams("branch", _plainSerDe.serializeString(branch)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients() .callBlocking(resolveBranchChannel, _request.build(), resolveBranchDeserializer); } @@ -557,14 +453,6 @@ public Optional testParam(AuthHeader authHeader, ResourceIdentifier data Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients().callBlocking(testParamChannel, _request.build(), testParamDeserializer); } @@ -591,14 +479,6 @@ public int testQueryParams( if (optionalEnd.isPresent()) { _request.putQueryParams("optionalEnd", _plainSerDe.serializeRid(optionalEnd.get())); } - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients() .callBlocking(testQueryParamsChannel, _request.build(), testQueryParamsDeserializer); } @@ -626,14 +506,6 @@ public void testNoResponseQueryParams( if (optionalEnd.isPresent()) { _request.putQueryParams("optionalEnd", _plainSerDe.serializeRid(optionalEnd.get())); } - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } _runtime.clients() .callBlocking( testNoResponseQueryParamsChannel, @@ -645,14 +517,6 @@ public void testNoResponseQueryParams( public boolean testBoolean(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients().callBlocking(testBooleanChannel, _request.build(), testBooleanDeserializer); } @@ -660,14 +524,6 @@ public boolean testBoolean(AuthHeader authHeader) { public double testDouble(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients().callBlocking(testDoubleChannel, _request.build(), testDoubleDeserializer); } @@ -675,14 +531,6 @@ public double testDouble(AuthHeader authHeader) { public int testInteger(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients().callBlocking(testIntegerChannel, _request.build(), testIntegerDeserializer); } @@ -691,14 +539,6 @@ public Optional testPostOptional(AuthHeader authHeader, Optional Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(testPostOptionalSerializer.serialize(maybeString)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients() .callBlocking(testPostOptionalChannel, _request.build(), testPostOptionalDeserializer); } @@ -714,14 +554,6 @@ public void testOptionalIntegerAndDouble( if (maybeDouble.isPresent()) { _request.putQueryParams("maybeDouble", _plainSerDe.serializeDouble(maybeDouble.getAsDouble())); } - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } _runtime.clients() .callBlocking( testOptionalIntegerAndDoubleChannel, @@ -738,14 +570,6 @@ public void getForStrings( for (AliasedString stringsElement : strings) { _request.putQueryParams("strings", _plainSerDe.serializeString(stringsElement.get())); } - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } _runtime.clients().callBlocking(getForStringsChannel, _request.build(), getForStringsDeserializer); } diff --git a/conjure-java-core/src/integrationInput/java/externalfallbacktypes/com/palantir/product/external/ServiceUsingExternalTypesAsync.java b/conjure-java-core/src/integrationInput/java/externalfallbacktypes/com/palantir/product/external/ServiceUsingExternalTypesAsync.java index bd47c7fbb..218786792 100644 --- a/conjure-java-core/src/integrationInput/java/externalfallbacktypes/com/palantir/product/external/ServiceUsingExternalTypesAsync.java +++ b/conjure-java-core/src/integrationInput/java/externalfallbacktypes/com/palantir/product/external/ServiceUsingExternalTypesAsync.java @@ -47,14 +47,6 @@ public ListenableFuture> external(String path, List Request.Builder _request = Request.builder(); _request.putPathParams("path", _plainSerDe.serializeString(path)); _request.body(externalSerializer.serialize(body)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients().call(externalChannel, _request.build(), externalDeserializer); } diff --git a/conjure-java-core/src/integrationInput/java/externalfallbacktypes/com/palantir/product/external/ServiceUsingExternalTypesBlocking.java b/conjure-java-core/src/integrationInput/java/externalfallbacktypes/com/palantir/product/external/ServiceUsingExternalTypesBlocking.java index 789f138f6..67cef41c1 100644 --- a/conjure-java-core/src/integrationInput/java/externalfallbacktypes/com/palantir/product/external/ServiceUsingExternalTypesBlocking.java +++ b/conjure-java-core/src/integrationInput/java/externalfallbacktypes/com/palantir/product/external/ServiceUsingExternalTypesBlocking.java @@ -47,14 +47,6 @@ public Map external(String path, List body) { Request.Builder _request = Request.builder(); _request.putPathParams("path", _plainSerDe.serializeString(path)); _request.body(externalSerializer.serialize(body)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients().callBlocking(externalChannel, _request.build(), externalDeserializer); } diff --git a/conjure-java-core/src/integrationInput/java/servicevanilla/com/palantir/another/TestServiceAsync.java b/conjure-java-core/src/integrationInput/java/servicevanilla/com/palantir/another/TestServiceAsync.java index 859ebb1b9..84376eb0a 100644 --- a/conjure-java-core/src/integrationInput/java/servicevanilla/com/palantir/another/TestServiceAsync.java +++ b/conjure-java-core/src/integrationInput/java/servicevanilla/com/palantir/another/TestServiceAsync.java @@ -325,14 +325,6 @@ static TestServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conju public ListenableFuture> getFileSystems(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients().call(getFileSystemsChannel, _request.build(), getFileSystemsDeserializer); } @@ -343,14 +335,6 @@ public ListenableFuture createDataset( _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(createDatasetSerializer.serialize(request)); _request.putHeaderParams("Test-Header", _plainSerDe.serializeString(testHeaderArg)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients().call(createDatasetChannel, _request.build(), createDatasetDeserializer); } @@ -360,14 +344,6 @@ public ListenableFuture> getDataset( Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients().call(getDatasetChannel, _request.build(), getDatasetDeserializer); } @@ -376,14 +352,6 @@ public ListenableFuture getRawData(AuthHeader authHeader, ResourceI Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients() .call( getRawDataChannel, @@ -397,14 +365,6 @@ public ListenableFuture getAliasedRawData( Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients() .call( getAliasedRawDataChannel, @@ -418,14 +378,6 @@ public ListenableFuture> maybeGetRawData( Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients() .call( maybeGetRawDataChannel, @@ -439,14 +391,6 @@ public ListenableFuture getAliasedString( Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients().call(getAliasedStringChannel, _request.build(), getAliasedStringDeserializer); } @@ -455,14 +399,6 @@ public ListenableFuture uploadRawData(AuthHeader authHeader, BinaryRequest Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(_runtime.bodySerDe().serialize(input)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients().call(uploadRawDataChannel, _request.build(), uploadRawDataDeserializer); } @@ -471,14 +407,6 @@ public ListenableFuture uploadAliasedRawData(AuthHeader authHeader, Binary Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(_runtime.bodySerDe().serialize(input)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients() .call(uploadAliasedRawDataChannel, _request.build(), uploadAliasedRawDataDeserializer); } @@ -488,14 +416,6 @@ public ListenableFuture> getBranches(AuthHeader authHeader, Resource Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients().call(getBranchesChannel, _request.build(), getBranchesDeserializer); } @@ -506,14 +426,6 @@ public ListenableFuture> getBranchesDeprecated( Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients() .call(getBranchesDeprecatedChannel, _request.build(), getBranchesDeprecatedDeserializer); } @@ -525,14 +437,6 @@ public ListenableFuture> getBranchesDeprecatedForRemoval( Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients() .call( getBranchesDeprecatedForRemovalChannel, @@ -547,14 +451,6 @@ public ListenableFuture> resolveBranch( _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); _request.putPathParams("branch", _plainSerDe.serializeString(branch)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients().call(resolveBranchChannel, _request.build(), resolveBranchDeserializer); } @@ -563,14 +459,6 @@ public ListenableFuture> testParam(AuthHeader authHeader, Resou Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients().call(testParamChannel, _request.build(), testParamDeserializer); } @@ -597,14 +485,6 @@ public ListenableFuture testQueryParams( if (optionalEnd.isPresent()) { _request.putQueryParams("optionalEnd", _plainSerDe.serializeRid(optionalEnd.get())); } - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients().call(testQueryParamsChannel, _request.build(), testQueryParamsDeserializer); } @@ -631,14 +511,6 @@ public ListenableFuture testNoResponseQueryParams( if (optionalEnd.isPresent()) { _request.putQueryParams("optionalEnd", _plainSerDe.serializeRid(optionalEnd.get())); } - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients() .call( testNoResponseQueryParamsChannel, @@ -650,14 +522,6 @@ public ListenableFuture testNoResponseQueryParams( public ListenableFuture testBoolean(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients().call(testBooleanChannel, _request.build(), testBooleanDeserializer); } @@ -665,14 +529,6 @@ public ListenableFuture testBoolean(AuthHeader authHeader) { public ListenableFuture testDouble(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients().call(testDoubleChannel, _request.build(), testDoubleDeserializer); } @@ -680,14 +536,6 @@ public ListenableFuture testDouble(AuthHeader authHeader) { public ListenableFuture testInteger(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients().call(testIntegerChannel, _request.build(), testIntegerDeserializer); } @@ -697,14 +545,6 @@ public ListenableFuture> testPostOptional( Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(testPostOptionalSerializer.serialize(maybeString)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients().call(testPostOptionalChannel, _request.build(), testPostOptionalDeserializer); } @@ -719,14 +559,6 @@ public ListenableFuture testOptionalIntegerAndDouble( if (maybeDouble.isPresent()) { _request.putQueryParams("maybeDouble", _plainSerDe.serializeDouble(maybeDouble.getAsDouble())); } - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients() .call( testOptionalIntegerAndDoubleChannel, @@ -743,14 +575,6 @@ public ListenableFuture getForStrings( for (AliasedString stringsElement : strings) { _request.putQueryParams("strings", _plainSerDe.serializeString(stringsElement.get())); } - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients().call(getForStringsChannel, _request.build(), getForStringsDeserializer); } diff --git a/conjure-java-core/src/integrationInput/java/servicevanilla/com/palantir/another/TestServiceBlocking.java b/conjure-java-core/src/integrationInput/java/servicevanilla/com/palantir/another/TestServiceBlocking.java index a32bc77ff..ded99ecc3 100644 --- a/conjure-java-core/src/integrationInput/java/servicevanilla/com/palantir/another/TestServiceBlocking.java +++ b/conjure-java-core/src/integrationInput/java/servicevanilla/com/palantir/another/TestServiceBlocking.java @@ -322,14 +322,6 @@ static TestServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Co public Map getFileSystems(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients() .callBlocking(getFileSystemsChannel, _request.build(), getFileSystemsDeserializer); } @@ -340,14 +332,6 @@ public Dataset createDataset(AuthHeader authHeader, String testHeaderArg, Create _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(createDatasetSerializer.serialize(request)); _request.putHeaderParams("Test-Header", _plainSerDe.serializeString(testHeaderArg)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients() .callBlocking(createDatasetChannel, _request.build(), createDatasetDeserializer); } @@ -357,14 +341,6 @@ public Optional getDataset(AuthHeader authHeader, ResourceIdentifier da Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients().callBlocking(getDatasetChannel, _request.build(), getDatasetDeserializer); } @@ -373,14 +349,6 @@ public InputStream getRawData(AuthHeader authHeader, ResourceIdentifier datasetR Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients() .callBlocking( getRawDataChannel, @@ -393,14 +361,6 @@ public InputStream getAliasedRawData(AuthHeader authHeader, ResourceIdentifier d Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients() .callBlocking( getAliasedRawDataChannel, @@ -413,14 +373,6 @@ public Optional maybeGetRawData(AuthHeader authHeader, ResourceIden Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients() .callBlocking( maybeGetRawDataChannel, @@ -433,14 +385,6 @@ public AliasedString getAliasedString(AuthHeader authHeader, ResourceIdentifier Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients() .callBlocking(getAliasedStringChannel, _request.build(), getAliasedStringDeserializer); } @@ -450,14 +394,6 @@ public void uploadRawData(AuthHeader authHeader, BinaryRequestBody input) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(_runtime.bodySerDe().serialize(input)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } _runtime.clients().callBlocking(uploadRawDataChannel, _request.build(), uploadRawDataDeserializer); } @@ -466,14 +402,6 @@ public void uploadAliasedRawData(AuthHeader authHeader, BinaryRequestBody input) Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(_runtime.bodySerDe().serialize(input)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } _runtime.clients() .callBlocking(uploadAliasedRawDataChannel, _request.build(), uploadAliasedRawDataDeserializer); } @@ -483,14 +411,6 @@ public Set getBranches(AuthHeader authHeader, ResourceIdentifier dataset Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients().callBlocking(getBranchesChannel, _request.build(), getBranchesDeserializer); } @@ -500,14 +420,6 @@ public Set getBranchesDeprecated(AuthHeader authHeader, ResourceIdentifi Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients() .callBlocking( getBranchesDeprecatedChannel, _request.build(), getBranchesDeprecatedDeserializer); @@ -519,14 +431,6 @@ public Set getBranchesDeprecatedForRemoval(AuthHeader authHeader, Resour Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients() .callBlocking( getBranchesDeprecatedForRemovalChannel, @@ -540,14 +444,6 @@ public Optional resolveBranch(AuthHeader authHeader, ResourceIdentifier _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); _request.putPathParams("branch", _plainSerDe.serializeString(branch)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients() .callBlocking(resolveBranchChannel, _request.build(), resolveBranchDeserializer); } @@ -557,14 +453,6 @@ public Optional testParam(AuthHeader authHeader, ResourceIdentifier data Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("datasetRid", _plainSerDe.serializeRid(datasetRid)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients().callBlocking(testParamChannel, _request.build(), testParamDeserializer); } @@ -591,14 +479,6 @@ public int testQueryParams( if (optionalEnd.isPresent()) { _request.putQueryParams("optionalEnd", _plainSerDe.serializeRid(optionalEnd.get())); } - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients() .callBlocking(testQueryParamsChannel, _request.build(), testQueryParamsDeserializer); } @@ -626,14 +506,6 @@ public void testNoResponseQueryParams( if (optionalEnd.isPresent()) { _request.putQueryParams("optionalEnd", _plainSerDe.serializeRid(optionalEnd.get())); } - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } _runtime.clients() .callBlocking( testNoResponseQueryParamsChannel, @@ -645,14 +517,6 @@ public void testNoResponseQueryParams( public boolean testBoolean(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients().callBlocking(testBooleanChannel, _request.build(), testBooleanDeserializer); } @@ -660,14 +524,6 @@ public boolean testBoolean(AuthHeader authHeader) { public double testDouble(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients().callBlocking(testDoubleChannel, _request.build(), testDoubleDeserializer); } @@ -675,14 +531,6 @@ public double testDouble(AuthHeader authHeader) { public int testInteger(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients().callBlocking(testIntegerChannel, _request.build(), testIntegerDeserializer); } @@ -691,14 +539,6 @@ public Optional testPostOptional(AuthHeader authHeader, Optional Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(testPostOptionalSerializer.serialize(maybeString)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients() .callBlocking(testPostOptionalChannel, _request.build(), testPostOptionalDeserializer); } @@ -714,14 +554,6 @@ public void testOptionalIntegerAndDouble( if (maybeDouble.isPresent()) { _request.putQueryParams("maybeDouble", _plainSerDe.serializeDouble(maybeDouble.getAsDouble())); } - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } _runtime.clients() .callBlocking( testOptionalIntegerAndDoubleChannel, @@ -738,14 +570,6 @@ public void getForStrings( for (AliasedString stringsElement : strings) { _request.putQueryParams("strings", _plainSerDe.serializeString(stringsElement.get())); } - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } _runtime.clients().callBlocking(getForStringsChannel, _request.build(), getForStringsDeserializer); } diff --git a/conjure-java-core/src/integrationInput/java/servicevanilla/test/api/CookieServiceAsync.java b/conjure-java-core/src/integrationInput/java/servicevanilla/test/api/CookieServiceAsync.java index 727bea4b6..f02385029 100644 --- a/conjure-java-core/src/integrationInput/java/servicevanilla/test/api/CookieServiceAsync.java +++ b/conjure-java-core/src/integrationInput/java/servicevanilla/test/api/CookieServiceAsync.java @@ -40,14 +40,6 @@ static CookieServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Con public ListenableFuture eatCookies(BearerToken token) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Cookie", "PALANTIR_TOKEN=" + _plainSerDe.serializeBearerToken(token)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } return _runtime.clients().call(eatCookiesChannel, _request.build(), eatCookiesDeserializer); } diff --git a/conjure-java-core/src/integrationInput/java/servicevanilla/test/api/CookieServiceBlocking.java b/conjure-java-core/src/integrationInput/java/servicevanilla/test/api/CookieServiceBlocking.java index 91772ca73..a92e5169b 100644 --- a/conjure-java-core/src/integrationInput/java/servicevanilla/test/api/CookieServiceBlocking.java +++ b/conjure-java-core/src/integrationInput/java/servicevanilla/test/api/CookieServiceBlocking.java @@ -39,14 +39,6 @@ static CookieServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, public void eatCookies(BearerToken token) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Cookie", "PALANTIR_TOKEN=" + _plainSerDe.serializeBearerToken(token)); - if (_runtime.bodySerDe().errorParameterDeserializationFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe() - .errorParameterDeserializationFormat() - .get() - .toString()); - } _runtime.clients().callBlocking(eatCookiesChannel, _request.build(), eatCookiesDeserializer); } diff --git a/conjure-java-core/src/main/java/com/palantir/conjure/java/services/dialogue/DefaultStaticFactoryMethodGenerator.java b/conjure-java-core/src/main/java/com/palantir/conjure/java/services/dialogue/DefaultStaticFactoryMethodGenerator.java index 4ed04ae52..b7adc924b 100644 --- a/conjure-java-core/src/main/java/com/palantir/conjure/java/services/dialogue/DefaultStaticFactoryMethodGenerator.java +++ b/conjure-java-core/src/main/java/com/palantir/conjure/java/services/dialogue/DefaultStaticFactoryMethodGenerator.java @@ -215,7 +215,7 @@ private Optional deserializer(EndpointName endpointName, Optional def.getEndpointName().get() + "Deserializer")); methodBuilder.addCode(request); - // If the BodySerDe.errorParameterDeserializationFormat field is set, add the header - methodBuilder.addCode(CodeBlock.builder() - .beginControlFlow("if ($L.bodySerDe().errorParameterDeserializationFormat().isPresent())", RUNTIME) - .add( - "$L.putHeaderParams($S," - + " $L.bodySerDe().errorParameterDeserializationFormat().get().toString());", - REQUEST, - "Accept-Conjure-Error-Parameter-Format", // TODO(pm): make this public. - RUNTIME) - .endControlFlow() - .build()); + if (options.generateErrorParameterFormatRespectingDialogueInterfaces()) { + // If the BodySerDe.errorParameterFormat field is set, add the header + methodBuilder.addCode(CodeBlock.builder() + .beginControlFlow("if ($L.bodySerDe().errorParameterFormat().isPresent())", RUNTIME) + .add( + "$L.putHeaderParams($S," + " $L.bodySerDe().errorParameterFormat().get().toString());", + REQUEST, + "Accept-Conjure-Error-Parameter-Format", // TODO(pm): make this public. + RUNTIME) + .endControlFlow() + .build()); + } methodBuilder.addCode(methodType.switchBy(def.getReturns().isPresent() ? "return " : "", "return ")); methodBuilder.addCode(execute); diff --git a/versions.lock b/versions.lock index 50564b747..f7d3e4424 100644 --- a/versions.lock +++ b/versions.lock @@ -64,15 +64,15 @@ com.palantir.dialogue:dialogue-apache-hc5-client:6.7.0 (2 constraints: 1a2974b6) com.palantir.dialogue:dialogue-blocking-channels:6.7.0 (2 constraints: 79232973) -com.palantir.dialogue:dialogue-clients:6.7.0 (1 constraints: cc07a77c) +com.palantir.dialogue:dialogue-clients:6.7.0 (1 constraints: 2908e185) com.palantir.dialogue:dialogue-core:6.7.0 (3 constraints: ea3c6541) com.palantir.dialogue:dialogue-futures:6.7.0 (3 constraints: 3e33a938) -com.palantir.dialogue:dialogue-serde:6.7.0 (3 constraints: e53088b3) +com.palantir.dialogue:dialogue-serde:6.7.0 (3 constraints: 423189e6) -com.palantir.dialogue:dialogue-target:6.7.0 (7 constraints: 8e7ae112) +com.palantir.dialogue:dialogue-target:6.7.0 (7 constraints: eb7a1d92) com.palantir.goethe:goethe:0.16.0 (1 constraints: 3905353b) diff --git a/versions.props b/versions.props index 2b45a4f08..c67cedf94 100644 --- a/versions.props +++ b/versions.props @@ -12,7 +12,7 @@ com.palantir.conjure.verification:* = 0.19.0 com.palantir.conjure:* = 4.50.0 com.palantir.deadlines:* = 0.15.0 com.palantir.goethe:* = 0.16.0 -com.palantir.dialogue:* = 6.4.0-9-g24023fe +com.palantir.dialogue:* = 6.5.0-23-g3d8fa00 com.palantir.human-readable-types:* = 1.7.0 com.palantir.javapoet:javapoet = 0.7.0 com.palantir.ri:resource-identifier = 2.11.0 From 1b5a8997f1f36c08676642af2ee1ed1cd51ad789 Mon Sep 17 00:00:00 2001 From: Pritham Marupaka Date: Tue, 19 Aug 2025 19:54:26 -0400 Subject: [PATCH 17/26] clean up --- .../conjure/java/types/ErrorGenerator.java | 19 +++++++++------- .../java/util/ErrorGenerationUtils.java | 22 ++++++++++++++----- 2 files changed, 27 insertions(+), 14 deletions(-) diff --git a/conjure-java-core/src/main/java/com/palantir/conjure/java/types/ErrorGenerator.java b/conjure-java-core/src/main/java/com/palantir/conjure/java/types/ErrorGenerator.java index 11c5c65ca..044234f0f 100644 --- a/conjure-java-core/src/main/java/com/palantir/conjure/java/types/ErrorGenerator.java +++ b/conjure-java-core/src/main/java/com/palantir/conjure/java/types/ErrorGenerator.java @@ -172,11 +172,14 @@ private JavaFile generateErrorTypesForNamespace( .addMethods(methodSpecs) .addMethods(checkMethodSpecs) .addMethods(isRemoteExceptionDefinitions) - .addAnnotation(ConjureAnnotations.getConjureGeneratedAnnotation(ErrorGenerator.class)) - .addAnnotation(ConjureAnnotations.getConjureGeneratedAnnotation(ErrorGenerator.class)) - .addTypes(generateErrorParameterRecords(errorTypeDefinitions, typeMapper)) - .addTypes(generateSerializableErrors(errorTypeDefinitions)) - .addTypes(generateRemoteExceptionTypes(errorTypeDefinitions)); + .addAnnotation(ConjureAnnotations.getConjureGeneratedAnnotation(ErrorGenerator.class)); + if (options.generateErrorParameterFormatRespectingDialogueInterfaces()) { + typeBuilder + .addTypes(generateErrorParameterRecords(errorTypeDefinitions, typeMapper)) + .addTypes(generateSerializableErrors(errorTypeDefinitions)) + .addTypes(generateRemoteExceptionTypes(errorTypeDefinitions)); + } + return JavaFile.builder(conjurePackage, typeBuilder.build()) .skipJavaLangImports(true) .indent(" ") @@ -308,11 +311,11 @@ private static TypeSpec generateErrorParameterRecord(ErrorDefinition errorDefini .addModifiers(Modifier.PUBLIC, Modifier.STATIC); MethodSpec.Builder ctorBuilder = MethodSpec.constructorBuilder(); for (FieldDefinition fieldDef : errorDefinition.getSafeArgs()) { - ctorBuilder.addParameter( - ErrorGenerationUtils.buildParameterWithSafetyAnnotationAndJsonProperty(typeMapper, fieldDef, true)); + ctorBuilder.addParameter(ErrorGenerationUtils.buildUnsanitizedParameterWithSafetyAnnotationAndJsonProperty( + typeMapper, fieldDef, true)); } for (FieldDefinition fieldDef : errorDefinition.getUnsafeArgs()) { - ctorBuilder.addParameter(ErrorGenerationUtils.buildParameterWithSafetyAnnotationAndJsonProperty( + ctorBuilder.addParameter(ErrorGenerationUtils.buildUnsanitizedParameterWithSafetyAnnotationAndJsonProperty( typeMapper, fieldDef, false)); } return parametersRecordBuilder.recordConstructor(ctorBuilder.build()).build(); diff --git a/conjure-java-core/src/main/java/com/palantir/conjure/java/util/ErrorGenerationUtils.java b/conjure-java-core/src/main/java/com/palantir/conjure/java/util/ErrorGenerationUtils.java index e3f908736..b6ab6a734 100644 --- a/conjure-java-core/src/main/java/com/palantir/conjure/java/util/ErrorGenerationUtils.java +++ b/conjure-java-core/src/main/java/com/palantir/conjure/java/util/ErrorGenerationUtils.java @@ -80,8 +80,6 @@ public static ParameterSpec buildParameterWithSafetyAnnotationAndJsonProperty( /** * A mapping from a package name to the list of errors defined within that package. This is used when attempting to * deserialize error responses from endpoints. - * - * TODO(pm): does this work with imported errors? */ public record PackageToErrorDefinitionsMapping(Map> packageToErrors) { public static PackageToErrorDefinitionsMapping from(ConjureDefinition definition) { @@ -178,15 +176,27 @@ public static void addAllParametersWithSafetyAnnotationsToMethodBuilder( public static ParameterSpec buildParameterWithSafetyAnnotation( TypeMapper typeMapper, FieldDefinition argDefinition, boolean isSafe) { - return buildParameterWithSafetyAnnotationInternal(typeMapper, argDefinition, isSafe) + return buildParameterWithSafetyAnnotationInternal(typeMapper, argDefinition, isSafe, true) .build(); } - private static ParameterSpec.Builder buildParameterWithSafetyAnnotationInternal( + public static ParameterSpec buildUnsanitizedParameterWithSafetyAnnotationAndJsonProperty( TypeMapper typeMapper, FieldDefinition argDefinition, boolean isSafe) { + ParameterSpec.Builder parameterBuilder = + buildParameterWithSafetyAnnotationInternal(typeMapper, argDefinition, isSafe, false); + parameterBuilder.addAnnotation(AnnotationSpec.builder(JsonProperty.class) + .addMember("value", "$S", argDefinition.getFieldName().get()) + .build()); + return parameterBuilder.build(); + } + + private static ParameterSpec.Builder buildParameterWithSafetyAnnotationInternal( + TypeMapper typeMapper, FieldDefinition argDefinition, boolean isSafe, boolean sanitizeName) { Optional safety = Optional.of(isSafe ? LogSafety.SAFE : LogSafety.UNSAFE); - String argName = JavaNameSanitizer.sanitizeErrorParameterName( - argDefinition.getFieldName().get()); + String argName = sanitizeName + ? JavaNameSanitizer.sanitizeErrorParameterName( + argDefinition.getFieldName().get()) + : argDefinition.getFieldName().get(); TypeName argType = ConjureAnnotations.withSafety(typeMapper.getClassName(argDefinition.getType()), safety); ParameterSpec.Builder parameterBuilder = ParameterSpec.builder(argType, argName); argDefinition From a935dff92028e78014c9b215ca10382466c1a247 Mon Sep 17 00:00:00 2001 From: Pritham Marupaka Date: Mon, 25 Aug 2025 14:56:29 -0400 Subject: [PATCH 18/26] cleanup after rebase --- changelog/@unreleased/pr-2588.v2.yml | 6 - conjure-java-client-verifier/build.gradle | 1 - .../com/palantir/product/ConjureErrors.java | 13 +- .../palantir/product/ConjureJavaErrors.java | 1 + .../another/EndpointSpecificErrors.java | 61 --- .../com/palantir/product/ConjureErrors.java | 67 --- .../palantir/product/ConjureServerErrors.java | 46 -- .../product/EndpointSpecificErrors.java | 66 --- .../product/EndpointSpecificTwoErrors.java | 61 --- .../com/palantir/product/ErrorService.java | 58 --- .../palantir/product/ErrorServiceAsync.java | 482 ------------------ .../product/ErrorServiceBlocking.java | 479 ----------------- .../product/ErrorServiceEndpoints.java | 345 ------------- .../com/palantir/product/TestErrors.java | 157 ------ .../com/palantir/another/ConjureErrors.java | 40 -- .../another/ConjureJavaOtherErrors.java | 40 -- .../com/palantir/product/ConjureErrors.java | 240 --------- .../palantir/product/ConjureJavaErrors.java | 40 -- .../another/EndpointSpecificErrors.java | 40 -- .../com/palantir/product/ConjureErrors.java | 44 -- .../product/EndpointSpecificErrors.java | 45 -- .../product/EndpointSpecificTwoErrors.java | 40 -- .../com/palantir/product/TestErrors.java | 120 ----- .../DefaultStaticFactoryMethodGenerator.java | 1 + .../conjure/java/types/ErrorGenerator.java | 7 +- .../java/util/ErrorGenerationUtils.java | 2 +- .../conjure/java/UndertowServiceEteTest.java | 2 +- versions.lock | 30 +- versions.props | 2 +- 29 files changed, 28 insertions(+), 2508 deletions(-) delete mode 100644 changelog/@unreleased/pr-2588.v2.yml delete mode 100644 conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/another/EndpointSpecificErrors.java delete mode 100644 conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ConjureErrors.java delete mode 100644 conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ConjureServerErrors.java delete mode 100644 conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/EndpointSpecificErrors.java delete mode 100644 conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/EndpointSpecificTwoErrors.java delete mode 100644 conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorService.java delete mode 100644 conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorServiceAsync.java delete mode 100644 conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorServiceBlocking.java delete mode 100644 conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorServiceEndpoints.java delete mode 100644 conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/TestErrors.java diff --git a/changelog/@unreleased/pr-2588.v2.yml b/changelog/@unreleased/pr-2588.v2.yml deleted file mode 100644 index f09bbb1ef..000000000 --- a/changelog/@unreleased/pr-2588.v2.yml +++ /dev/null @@ -1,6 +0,0 @@ -type: improvement -improvement: - description: When the `Accept-Conjure-Error-Parameter-Format` header is `JSON`, - servers serialize error parameters as JSON, instead of using `Objects.toString`. - links: - - https://github.com/palantir/conjure-java/pull/2588 diff --git a/conjure-java-client-verifier/build.gradle b/conjure-java-client-verifier/build.gradle index 3af24a118..3bddaa15d 100644 --- a/conjure-java-client-verifier/build.gradle +++ b/conjure-java-client-verifier/build.gradle @@ -76,7 +76,6 @@ project('verification-server-api') { implementation 'com.palantir.safe-logging:preconditions' implementation 'com.palantir.safe-logging:safe-logging' implementation 'com.palantir.tokens:auth-tokens' - implementation 'com.palantir.conjure.java.api:errors' } } diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureErrors.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureErrors.java index bf459d411..89befeff1 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureErrors.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureErrors.java @@ -329,11 +329,12 @@ public static boolean isInvalidTypeDefinition(RemoteException remoteException) { Preconditions.checkNotNull(remoteException, "remote exception must not be null"); return INVALID_TYPE_DEFINITION.name().equals(remoteException.getError().errorName()); } + public static record ConflictingCauseSafeArgParameters( - @JsonProperty("cause") @Safe String cause_, @JsonProperty("shouldThrow") @Safe boolean shouldThrow_) {} + @JsonProperty("cause") @Safe String cause, @JsonProperty("shouldThrow") @Safe boolean shouldThrow) {} public static record ConflictingCauseUnsafeArgParameters( - @JsonProperty("cause") @Unsafe String cause_, @JsonProperty("shouldThrow") @Unsafe boolean shouldThrow_) {} + @JsonProperty("cause") @Unsafe String cause, @JsonProperty("shouldThrow") @Unsafe boolean shouldThrow) {} public static record ErrorWithComplexArgsParameters( @JsonProperty("primitiveExample") @Safe PrimitiveExample primitiveExample, @@ -377,8 +378,8 @@ public static final class ConflictingCauseSafeArgSerializableError public SerializableError toSerializableError() { return SerializableError.builder() - .putParameters("cause", Objects.toString(parameters().cause_())) - .putParameters("shouldThrow", Objects.toString(parameters().shouldThrow_())) + .putParameters("cause", Objects.toString(parameters().cause())) + .putParameters("shouldThrow", Objects.toString(parameters().shouldThrow())) .errorCode(errorCode()) .errorName(errorName()) .errorInstanceId(errorInstanceId()) @@ -399,8 +400,8 @@ public static final class ConflictingCauseUnsafeArgSerializableError public SerializableError toSerializableError() { return SerializableError.builder() - .putParameters("cause", Objects.toString(parameters().cause_())) - .putParameters("shouldThrow", Objects.toString(parameters().shouldThrow_())) + .putParameters("cause", Objects.toString(parameters().cause())) + .putParameters("shouldThrow", Objects.toString(parameters().shouldThrow())) .errorCode(errorCode()) .errorName(errorName()) .errorInstanceId(errorInstanceId()) diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureJavaErrors.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureJavaErrors.java index 35e2e7d77..ff44ed2c9 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureJavaErrors.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureJavaErrors.java @@ -44,6 +44,7 @@ public static boolean isJavaCompilationFailed(RemoteException remoteException) { Preconditions.checkNotNull(remoteException, "remote exception must not be null"); return JAVA_COMPILATION_FAILED.name().equals(remoteException.getError().errorName()); } + public static record JavaCompilationFailedParameters() {} public static final class JavaCompilationFailedSerializableError diff --git a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/another/EndpointSpecificErrors.java b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/another/EndpointSpecificErrors.java deleted file mode 100644 index ca932a3cc..000000000 --- a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/another/EndpointSpecificErrors.java +++ /dev/null @@ -1,61 +0,0 @@ -package dialogueendpointresulttypes.com.palantir.another; - -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.palantir.conjure.java.api.errors.AbstractSerializableError; -import com.palantir.conjure.java.api.errors.ErrorType; -import com.palantir.conjure.java.api.errors.RemoteException; -import com.palantir.conjure.java.api.errors.SerializableError; -import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.Safe; -import javax.annotation.processing.Generated; - -@Generated("com.palantir.conjure.java.types.ErrorGenerator") -public final class EndpointSpecificErrors { - /** An error in a different package. */ - public static final ErrorType DIFFERENT_PACKAGE = - ErrorType.create(ErrorType.Code.INTERNAL, "EndpointSpecific:DifferentPackage"); - - private EndpointSpecificErrors() {} - - /** Returns true if the {@link RemoteException} is named EndpointSpecific:DifferentPackage */ - public static boolean isDifferentPackage(RemoteException remoteException) { - Preconditions.checkNotNull(remoteException, "remote exception must not be null"); - return DIFFERENT_PACKAGE.name().equals(remoteException.getError().errorName()); - } - - public static record DifferentPackageParameters() {} - - public static final class DifferentPackageSerializableError - extends AbstractSerializableError { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - DifferentPackageSerializableError( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorName") @Safe String errorName, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") DifferentPackageParameters parameters) { - super(errorCode, errorName, errorInstanceId, parameters); - } - - public SerializableError toSerializableError() { - return SerializableError.builder() - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()) - .build(); - } - } - - public static final class DifferentPackageException extends RemoteException { - private DifferentPackageSerializableError error; - - public DifferentPackageException(DifferentPackageSerializableError error, int status) { - super(error.toSerializableError(), status); - this.error = error; - } - - public DifferentPackageSerializableError error() { - return error; - } - } -} diff --git a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ConjureErrors.java b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ConjureErrors.java deleted file mode 100644 index ec5f3ff40..000000000 --- a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ConjureErrors.java +++ /dev/null @@ -1,67 +0,0 @@ -package dialogueendpointresulttypes.com.palantir.product; - -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.palantir.conjure.java.api.errors.AbstractSerializableError; -import com.palantir.conjure.java.api.errors.ErrorType; -import com.palantir.conjure.java.api.errors.RemoteException; -import com.palantir.conjure.java.api.errors.SerializableError; -import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.Safe; -import java.util.Objects; -import javax.annotation.processing.Generated; - -@Generated("com.palantir.conjure.java.types.ErrorGenerator") -public final class ConjureErrors { - /** Cause argument conflicts with reserved Throwable cause parameter. */ - public static final ErrorType CONFLICTING_CAUSE_SAFE_ARG_ERR = - ErrorType.create(ErrorType.Code.INTERNAL, "Conjure:ConflictingCauseSafeArgErr"); - - private ConjureErrors() {} - - /** Returns true if the {@link RemoteException} is named Conjure:ConflictingCauseSafeArgErr */ - public static boolean isConflictingCauseSafeArgErr(RemoteException remoteException) { - Preconditions.checkNotNull(remoteException, "remote exception must not be null"); - return CONFLICTING_CAUSE_SAFE_ARG_ERR - .name() - .equals(remoteException.getError().errorName()); - } - - public static record ConflictingCauseSafeArgErrParameters( - @JsonProperty("cause") @Safe String cause_, @JsonProperty("shouldThrow") @Safe boolean shouldThrow_) {} - - public static final class ConflictingCauseSafeArgErrSerializableError - extends AbstractSerializableError { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - ConflictingCauseSafeArgErrSerializableError( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorName") @Safe String errorName, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") ConflictingCauseSafeArgErrParameters parameters) { - super(errorCode, errorName, errorInstanceId, parameters); - } - - public SerializableError toSerializableError() { - return SerializableError.builder() - .putParameters("cause", Objects.toString(parameters().cause_())) - .putParameters("shouldThrow", Objects.toString(parameters().shouldThrow_())) - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()) - .build(); - } - } - - public static final class ConflictingCauseSafeArgErrException extends RemoteException { - private ConflictingCauseSafeArgErrSerializableError error; - - public ConflictingCauseSafeArgErrException(ConflictingCauseSafeArgErrSerializableError error, int status) { - super(error.toSerializableError(), status); - this.error = error; - } - - public ConflictingCauseSafeArgErrSerializableError error() { - return error; - } - } -} diff --git a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ConjureServerErrors.java b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ConjureServerErrors.java deleted file mode 100644 index 23539b031..000000000 --- a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ConjureServerErrors.java +++ /dev/null @@ -1,46 +0,0 @@ -package dialogueendpointresulttypes.com.palantir.product; - -import com.palantir.conjure.java.api.errors.EndpointServiceException; -import com.palantir.logsafe.Safe; -import com.palantir.logsafe.SafeArg; -import javax.annotation.Nullable; -import javax.annotation.processing.Generated; - -@Generated("com.palantir.conjure.java.types.EndpointErrorGenerator") -public final class ConjureServerErrors { - private ConjureServerErrors() {} - - public static ConflictingCauseSafeArgErr conflictingCauseSafeArgErr( - @Safe String cause_, @Safe boolean shouldThrow_) { - return new ConflictingCauseSafeArgErr(cause_, shouldThrow_, null); - } - - public static ConflictingCauseSafeArgErr conflictingCauseSafeArgErr( - @Safe String cause_, @Safe boolean shouldThrow_, @Nullable Throwable cause) { - return new ConflictingCauseSafeArgErr(cause_, shouldThrow_, cause); - } - - /** - * Throws a {@link ConflictingCauseSafeArgErr} when {@code shouldThrow} is true. - * - * @param shouldThrow Cause the method to throw when true - * @param cause_ - * @param shouldThrow_ - */ - public static void throwIfConflictingCauseSafeArgErr( - boolean shouldThrow, @Safe String cause_, @Safe boolean shouldThrow_) { - if (shouldThrow) { - throw conflictingCauseSafeArgErr(cause_, shouldThrow_); - } - } - - public static final class ConflictingCauseSafeArgErr extends EndpointServiceException { - private ConflictingCauseSafeArgErr(@Safe String cause_, @Safe boolean shouldThrow_, @Nullable Throwable cause) { - super( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG_ERR, - cause, - SafeArg.of("cause", cause_), - SafeArg.of("shouldThrow", shouldThrow_)); - } - } -} diff --git a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/EndpointSpecificErrors.java b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/EndpointSpecificErrors.java deleted file mode 100644 index 24f857a1d..000000000 --- a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/EndpointSpecificErrors.java +++ /dev/null @@ -1,66 +0,0 @@ -package dialogueendpointresulttypes.com.palantir.product; - -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.palantir.conjure.java.api.errors.AbstractSerializableError; -import com.palantir.conjure.java.api.errors.ErrorType; -import com.palantir.conjure.java.api.errors.RemoteException; -import com.palantir.conjure.java.api.errors.SerializableError; -import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.Safe; -import com.palantir.logsafe.Unsafe; -import java.util.Objects; -import javax.annotation.processing.Generated; - -@Generated("com.palantir.conjure.java.types.ErrorGenerator") -public final class EndpointSpecificErrors { - /** Docs for an endpoint error. */ - public static final ErrorType ENDPOINT_ERROR = - ErrorType.create(ErrorType.Code.INVALID_ARGUMENT, "EndpointSpecific:EndpointError"); - - private EndpointSpecificErrors() {} - - /** Returns true if the {@link RemoteException} is named EndpointSpecific:EndpointError */ - public static boolean isEndpointError(RemoteException remoteException) { - Preconditions.checkNotNull(remoteException, "remote exception must not be null"); - return ENDPOINT_ERROR.name().equals(remoteException.getError().errorName()); - } - - public static record EndpointErrorParameters( - @JsonProperty("typeName") @Safe String typeName, @JsonProperty("typeDef") @Unsafe Object typeDef) {} - - public static final class EndpointErrorSerializableError - extends AbstractSerializableError { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - EndpointErrorSerializableError( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorName") @Safe String errorName, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") EndpointErrorParameters parameters) { - super(errorCode, errorName, errorInstanceId, parameters); - } - - public SerializableError toSerializableError() { - return SerializableError.builder() - .putParameters("typeName", Objects.toString(parameters().typeName())) - .putParameters("typeDef", Objects.toString(parameters().typeDef())) - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()) - .build(); - } - } - - public static final class EndpointErrorException extends RemoteException { - private EndpointErrorSerializableError error; - - public EndpointErrorException(EndpointErrorSerializableError error, int status) { - super(error.toSerializableError(), status); - this.error = error; - } - - public EndpointErrorSerializableError error() { - return error; - } - } -} diff --git a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/EndpointSpecificTwoErrors.java b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/EndpointSpecificTwoErrors.java deleted file mode 100644 index aa010eaea..000000000 --- a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/EndpointSpecificTwoErrors.java +++ /dev/null @@ -1,61 +0,0 @@ -package dialogueendpointresulttypes.com.palantir.product; - -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.palantir.conjure.java.api.errors.AbstractSerializableError; -import com.palantir.conjure.java.api.errors.ErrorType; -import com.palantir.conjure.java.api.errors.RemoteException; -import com.palantir.conjure.java.api.errors.SerializableError; -import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.Safe; -import javax.annotation.processing.Generated; - -@Generated("com.palantir.conjure.java.types.ErrorGenerator") -public final class EndpointSpecificTwoErrors { - /** An error in a different namespace. */ - public static final ErrorType DIFFERENT_NAMESPACE = - ErrorType.create(ErrorType.Code.INTERNAL, "EndpointSpecificTwo:DifferentNamespace"); - - private EndpointSpecificTwoErrors() {} - - /** Returns true if the {@link RemoteException} is named EndpointSpecificTwo:DifferentNamespace */ - public static boolean isDifferentNamespace(RemoteException remoteException) { - Preconditions.checkNotNull(remoteException, "remote exception must not be null"); - return DIFFERENT_NAMESPACE.name().equals(remoteException.getError().errorName()); - } - - public static record DifferentNamespaceParameters() {} - - public static final class DifferentNamespaceSerializableError - extends AbstractSerializableError { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - DifferentNamespaceSerializableError( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorName") @Safe String errorName, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") DifferentNamespaceParameters parameters) { - super(errorCode, errorName, errorInstanceId, parameters); - } - - public SerializableError toSerializableError() { - return SerializableError.builder() - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()) - .build(); - } - } - - public static final class DifferentNamespaceException extends RemoteException { - private DifferentNamespaceSerializableError error; - - public DifferentNamespaceException(DifferentNamespaceSerializableError error, int status) { - super(error.toSerializableError(), status); - this.error = error; - } - - public DifferentNamespaceSerializableError error() { - return error; - } - } -} diff --git a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorService.java b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorService.java deleted file mode 100644 index 3d350a4c9..000000000 --- a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorService.java +++ /dev/null @@ -1,58 +0,0 @@ -package dialogueendpointresulttypes.com.palantir.product; - -import com.palantir.conjure.java.undertow.lib.BinaryResponseBody; -import com.palantir.tokens.auth.AuthHeader; -import java.util.Optional; -import javax.annotation.processing.Generated; - -@Generated("com.palantir.conjure.java.services.UndertowServiceInterfaceGenerator") -public interface ErrorService { - /** - * @apiNote {@code POST /errors/basic} - * @throws TestServerErrors.InvalidArgument - * @throws ConjureServerErrors.ConflictingCauseSafeArgErr - */ - String testBasicError(AuthHeader authHeader, boolean shouldThrowError) - throws TestServerErrors.InvalidArgument, ConjureServerErrors.ConflictingCauseSafeArgErr; - - /** - * @apiNote {@code POST /errors/imported} - * @throws EndpointSpecificServerErrors.EndpointError - */ - String testImportedError(AuthHeader authHeader, boolean shouldThrowError) - throws EndpointSpecificServerErrors.EndpointError; - - /** - * @apiNote {@code POST /errors/multiple} - * @throws TestServerErrors.InvalidArgument - * @throws TestServerErrors.NotFound Something was not found. - * @throws EndpointSpecificTwoServerErrors.DifferentNamespace - * @throws dialogueendpointresulttypes.com.palantir.another.EndpointSpecificServerErrors.DifferentPackage - * @throws TestServerErrors.ComplicatedParameters - */ - String testMultipleErrorsAndPackages(AuthHeader authHeader, Optional errorToThrow) - throws TestServerErrors.InvalidArgument, TestServerErrors.NotFound, - EndpointSpecificTwoServerErrors.DifferentNamespace, - dialogueendpointresulttypes.com.palantir.another.EndpointSpecificServerErrors.DifferentPackage, - TestServerErrors.ComplicatedParameters; - - /** - * @apiNote {@code POST /errors/empty} - * @throws TestServerErrors.InvalidArgument - */ - void testEmptyBody(AuthHeader authHeader, boolean shouldThrowError) throws TestServerErrors.InvalidArgument; - - /** - * @apiNote {@code POST /errors/binary} - * @throws TestServerErrors.InvalidArgument - */ - BinaryResponseBody testBinary(AuthHeader authHeader, boolean shouldThrowError) - throws TestServerErrors.InvalidArgument; - - /** - * @apiNote {@code POST /errors/optional-binary} - * @throws TestServerErrors.InvalidArgument - */ - Optional testOptionalBinary(AuthHeader authHeader, OptionalBinaryResponseMode mode) - throws TestServerErrors.InvalidArgument; -} diff --git a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorServiceAsync.java b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorServiceAsync.java deleted file mode 100644 index 06c57b75c..000000000 --- a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorServiceAsync.java +++ /dev/null @@ -1,482 +0,0 @@ -package dialogueendpointresulttypes.com.palantir.product; - -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.fasterxml.jackson.annotation.JsonValue; -import com.google.common.util.concurrent.ListenableFuture; -import com.google.errorprone.annotations.CheckReturnValue; -import com.google.errorprone.annotations.MustBeClosed; -import com.palantir.conjure.java.lib.internal.ClientEndpoint; -import com.palantir.dialogue.Channel; -import com.palantir.dialogue.ConjureRuntime; -import com.palantir.dialogue.Deserializer; -import com.palantir.dialogue.DeserializerArgs; -import com.palantir.dialogue.DialogueService; -import com.palantir.dialogue.DialogueServiceFactory; -import com.palantir.dialogue.Endpoint; -import com.palantir.dialogue.EndpointChannel; -import com.palantir.dialogue.EndpointChannelFactory; -import com.palantir.dialogue.EndpointError; -import com.palantir.dialogue.PlainSerDe; -import com.palantir.dialogue.Request; -import com.palantir.dialogue.Serializer; -import com.palantir.dialogue.TypeMarker; -import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.Safe; -import com.palantir.tokens.auth.AuthHeader; -import java.io.Closeable; -import java.io.IOException; -import java.io.InputStream; -import java.lang.Boolean; -import java.lang.Override; -import java.lang.String; -import java.util.Optional; -import javax.annotation.processing.Generated; - -@Generated("com.palantir.conjure.java.services.dialogue.DialogueInterfaceGenerator") -@DialogueService(ErrorServiceAsync.Factory.class) -public interface ErrorServiceAsync { - /** @apiNote {@code POST /errors/basic} */ - @ClientEndpoint(method = "POST", path = "/errors/basic") - @CheckReturnValue - ListenableFuture testBasicError(AuthHeader authHeader, boolean shouldThrowError); - - /** @apiNote {@code POST /errors/imported} */ - @ClientEndpoint(method = "POST", path = "/errors/imported") - @CheckReturnValue - ListenableFuture testImportedError(AuthHeader authHeader, boolean shouldThrowError); - - /** @apiNote {@code POST /errors/multiple} */ - @ClientEndpoint(method = "POST", path = "/errors/multiple") - @CheckReturnValue - ListenableFuture testMultipleErrorsAndPackages( - AuthHeader authHeader, Optional errorToThrow); - - /** @apiNote {@code POST /errors/empty} */ - @ClientEndpoint(method = "POST", path = "/errors/empty") - @CheckReturnValue - ListenableFuture testEmptyBody(AuthHeader authHeader, boolean shouldThrowError); - - /** @apiNote {@code POST /errors/binary} */ - @ClientEndpoint(method = "POST", path = "/errors/binary") - @CheckReturnValue - ListenableFuture testBinary(AuthHeader authHeader, boolean shouldThrowError); - - /** @apiNote {@code POST /errors/optional-binary} */ - @ClientEndpoint(method = "POST", path = "/errors/optional-binary") - @CheckReturnValue - ListenableFuture testOptionalBinary( - AuthHeader authHeader, OptionalBinaryResponseMode mode); - - /** Creates an asynchronous/non-blocking client for a ErrorService service. */ - static ErrorServiceAsync of(EndpointChannelFactory _endpointChannelFactory, ConjureRuntime _runtime) { - return new ErrorServiceAsync() { - private final PlainSerDe _plainSerDe = _runtime.plainSerDe(); - - private final Serializer testBasicErrorSerializer = - _runtime.bodySerDe().serializer(new TypeMarker() {}); - - private final EndpointChannel testBasicErrorChannel = - _endpointChannelFactory.endpoint(DialogueErrorEndpoints.testBasicError); - - private final Deserializer testBasicErrorDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) - .error( - TestErrors.INVALID_ARGUMENT.name(), - new TypeMarker() {}) - .error( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG_ERR.name(), - new TypeMarker() {}) - .build()); - - private final Serializer testImportedErrorSerializer = - _runtime.bodySerDe().serializer(new TypeMarker() {}); - - private final EndpointChannel testImportedErrorChannel = - _endpointChannelFactory.endpoint(DialogueErrorEndpoints.testImportedError); - - private final Deserializer testImportedErrorDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) - .error( - EndpointSpecificErrors.ENDPOINT_ERROR.name(), - new TypeMarker() {}) - .build()); - - private final Serializer> testMultipleErrorsAndPackagesSerializer = - _runtime.bodySerDe().serializer(new TypeMarker>() {}); - - private final EndpointChannel testMultipleErrorsAndPackagesChannel = - _endpointChannelFactory.endpoint(DialogueErrorEndpoints.testMultipleErrorsAndPackages); - - private final Deserializer - testMultipleErrorsAndPackagesDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) - .error( - TestErrors.INVALID_ARGUMENT.name(), - new TypeMarker() {}) - .error( - TestErrors.NOT_FOUND.name(), - new TypeMarker() {}) - .error( - EndpointSpecificTwoErrors.DIFFERENT_NAMESPACE.name(), - new TypeMarker< - TestMultipleErrorsAndPackagesResponse.DifferentNamespace>() {}) - .error( - dialogueendpointresulttypes.com.palantir.another.EndpointSpecificErrors - .DIFFERENT_PACKAGE - .name(), - new TypeMarker() {}) - .error( - TestErrors.COMPLICATED_PARAMETERS.name(), - new TypeMarker< - TestMultipleErrorsAndPackagesResponse.ComplicatedParameters>() {}) - .build()); - - private final Serializer testEmptyBodySerializer = - _runtime.bodySerDe().serializer(new TypeMarker() {}); - - private final EndpointChannel testEmptyBodyChannel = - _endpointChannelFactory.endpoint(DialogueErrorEndpoints.testEmptyBody); - - private final Deserializer testEmptyBodyDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) - .error( - TestErrors.INVALID_ARGUMENT.name(), - new TypeMarker() {}) - .build()); - - private final Serializer testBinarySerializer = - _runtime.bodySerDe().serializer(new TypeMarker() {}); - - private final EndpointChannel testBinaryChannel = - _endpointChannelFactory.endpoint(DialogueErrorEndpoints.testBinary); - - private final Deserializer testBinaryDeserializer = _runtime.bodySerDe() - .inputStreamDeserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) - .error( - TestErrors.INVALID_ARGUMENT.name(), - new TypeMarker() {}) - .build()); - - private final Serializer testOptionalBinarySerializer = - _runtime.bodySerDe().serializer(new TypeMarker() {}); - - private final EndpointChannel testOptionalBinaryChannel = - _endpointChannelFactory.endpoint(DialogueErrorEndpoints.testOptionalBinary); - - private final Deserializer testOptionalBinaryDeserializer = _runtime.bodySerDe() - .optionalInputStreamDeserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) - .error( - TestErrors.INVALID_ARGUMENT.name(), - new TypeMarker() {}) - .build()); - - @Override - public ListenableFuture testBasicError( - AuthHeader authHeader, boolean shouldThrowError) { - Request.Builder _request = Request.builder(); - _request.putHeaderParams("Authorization", authHeader.toString()); - _request.body(testBasicErrorSerializer.serialize(shouldThrowError)); - return _runtime.clients().call(testBasicErrorChannel, _request.build(), testBasicErrorDeserializer); - } - - @Override - public ListenableFuture testImportedError( - AuthHeader authHeader, boolean shouldThrowError) { - Request.Builder _request = Request.builder(); - _request.putHeaderParams("Authorization", authHeader.toString()); - _request.body(testImportedErrorSerializer.serialize(shouldThrowError)); - return _runtime.clients() - .call(testImportedErrorChannel, _request.build(), testImportedErrorDeserializer); - } - - @Override - public ListenableFuture testMultipleErrorsAndPackages( - AuthHeader authHeader, Optional errorToThrow) { - Request.Builder _request = Request.builder(); - _request.putHeaderParams("Authorization", authHeader.toString()); - _request.body(testMultipleErrorsAndPackagesSerializer.serialize(errorToThrow)); - return _runtime.clients() - .call( - testMultipleErrorsAndPackagesChannel, - _request.build(), - testMultipleErrorsAndPackagesDeserializer); - } - - @Override - public ListenableFuture testEmptyBody( - AuthHeader authHeader, boolean shouldThrowError) { - Request.Builder _request = Request.builder(); - _request.putHeaderParams("Authorization", authHeader.toString()); - _request.body(testEmptyBodySerializer.serialize(shouldThrowError)); - return _runtime.clients().call(testEmptyBodyChannel, _request.build(), testEmptyBodyDeserializer); - } - - @Override - public ListenableFuture testBinary(AuthHeader authHeader, boolean shouldThrowError) { - Request.Builder _request = Request.builder(); - _request.putHeaderParams("Authorization", authHeader.toString()); - _request.body(testBinarySerializer.serialize(shouldThrowError)); - return _runtime.clients().call(testBinaryChannel, _request.build(), testBinaryDeserializer); - } - - @Override - public ListenableFuture testOptionalBinary( - AuthHeader authHeader, OptionalBinaryResponseMode mode) { - Request.Builder _request = Request.builder(); - _request.putHeaderParams("Authorization", authHeader.toString()); - _request.body(testOptionalBinarySerializer.serialize(mode)); - return _runtime.clients() - .call(testOptionalBinaryChannel, _request.build(), testOptionalBinaryDeserializer); - } - - @Override - public String toString() { - return "ErrorServiceAsync{_endpointChannelFactory=" + _endpointChannelFactory + ", runtime=" + _runtime - + '}'; - } - }; - } - - /** Creates an asynchronous/non-blocking client for a ErrorService service. */ - static ErrorServiceAsync of(Channel _channel, ConjureRuntime _runtime) { - if (_channel instanceof EndpointChannelFactory) { - return of((EndpointChannelFactory) _channel, _runtime); - } - return of( - new EndpointChannelFactory() { - @Override - public EndpointChannel endpoint(Endpoint endpoint) { - return _runtime.clients().bind(_channel, endpoint); - } - }, - _runtime); - } - - final class Factory implements DialogueServiceFactory { - @Override - public ErrorServiceAsync create(EndpointChannelFactory endpointChannelFactory, ConjureRuntime runtime) { - return ErrorServiceAsync.of(endpointChannelFactory, runtime); - } - } - - sealed interface TestBasicErrorResponse - permits TestBasicErrorResponse.Success, - TestBasicErrorResponse.InvalidArgument, - TestBasicErrorResponse.ConflictingCauseSafeArgErr { - record Success(@JsonValue String value) implements TestBasicErrorResponse { - public Success { - Preconditions.checkArgumentNotNull(value, "value cannot be null"); - } - } - - final class InvalidArgument extends EndpointError - implements TestBasicErrorResponse { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - InvalidArgument( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") TestErrors.InvalidArgumentParameters parameters) { - super(errorCode, TestErrors.INVALID_ARGUMENT.name(), errorInstanceId, parameters); - } - } - - final class ConflictingCauseSafeArgErr extends EndpointError - implements TestBasicErrorResponse { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - ConflictingCauseSafeArgErr( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") ConjureErrors.ConflictingCauseSafeArgErrParameters parameters) { - super(errorCode, ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG_ERR.name(), errorInstanceId, parameters); - } - } - } - - sealed interface TestImportedErrorResponse - permits TestImportedErrorResponse.Success, TestImportedErrorResponse.EndpointError { - record Success(@JsonValue String value) implements TestImportedErrorResponse { - public Success { - Preconditions.checkArgumentNotNull(value, "value cannot be null"); - } - } - - final class EndpointError - extends com.palantir.dialogue.EndpointError - implements TestImportedErrorResponse { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - EndpointError( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") EndpointSpecificErrors.EndpointErrorParameters parameters) { - super(errorCode, EndpointSpecificErrors.ENDPOINT_ERROR.name(), errorInstanceId, parameters); - } - } - } - - sealed interface TestMultipleErrorsAndPackagesResponse - permits TestMultipleErrorsAndPackagesResponse.Success, - TestMultipleErrorsAndPackagesResponse.InvalidArgument, - TestMultipleErrorsAndPackagesResponse.NotFound, - TestMultipleErrorsAndPackagesResponse.DifferentNamespace, - TestMultipleErrorsAndPackagesResponse.DifferentPackage, - TestMultipleErrorsAndPackagesResponse.ComplicatedParameters { - record Success(@JsonValue String value) implements TestMultipleErrorsAndPackagesResponse { - public Success { - Preconditions.checkArgumentNotNull(value, "value cannot be null"); - } - } - - final class InvalidArgument extends EndpointError - implements TestMultipleErrorsAndPackagesResponse { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - InvalidArgument( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") TestErrors.InvalidArgumentParameters parameters) { - super(errorCode, TestErrors.INVALID_ARGUMENT.name(), errorInstanceId, parameters); - } - } - - final class NotFound extends EndpointError - implements TestMultipleErrorsAndPackagesResponse { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - NotFound( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") TestErrors.NotFoundParameters parameters) { - super(errorCode, TestErrors.NOT_FOUND.name(), errorInstanceId, parameters); - } - } - - final class DifferentNamespace extends EndpointError - implements TestMultipleErrorsAndPackagesResponse { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - DifferentNamespace( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId) { - super( - errorCode, - EndpointSpecificTwoErrors.DIFFERENT_NAMESPACE.name(), - errorInstanceId, - new EndpointSpecificTwoErrors.DifferentNamespaceParameters()); - } - } - - final class DifferentPackage - extends EndpointError< - dialogueendpointresulttypes.com.palantir.another.EndpointSpecificErrors - .DifferentPackageParameters> - implements TestMultipleErrorsAndPackagesResponse { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - DifferentPackage( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId) { - super( - errorCode, - dialogueendpointresulttypes.com.palantir.another.EndpointSpecificErrors.DIFFERENT_PACKAGE - .name(), - errorInstanceId, - new dialogueendpointresulttypes.com.palantir.another.EndpointSpecificErrors - .DifferentPackageParameters()); - } - } - - final class ComplicatedParameters extends EndpointError - implements TestMultipleErrorsAndPackagesResponse { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - ComplicatedParameters( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") TestErrors.ComplicatedParametersParameters parameters) { - super(errorCode, TestErrors.COMPLICATED_PARAMETERS.name(), errorInstanceId, parameters); - } - } - } - - sealed interface TestEmptyBodyResponse - permits TestEmptyBodyResponse.Success, TestEmptyBodyResponse.InvalidArgument { - record Success() implements TestEmptyBodyResponse {} - - final class InvalidArgument extends EndpointError - implements TestEmptyBodyResponse { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - InvalidArgument( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") TestErrors.InvalidArgumentParameters parameters) { - super(errorCode, TestErrors.INVALID_ARGUMENT.name(), errorInstanceId, parameters); - } - } - } - - sealed interface TestBinaryResponse extends Closeable - permits TestBinaryResponse.Success, TestBinaryResponse.InvalidArgument { - @Override - default void close() throws IOException {} - - record Success(@MustBeClosed @JsonValue InputStream value) implements TestBinaryResponse { - public Success { - Preconditions.checkArgumentNotNull(value, "value cannot be null"); - } - - @Override - public void close() throws IOException { - value.close(); - } - } - - final class InvalidArgument extends EndpointError - implements TestBinaryResponse { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - InvalidArgument( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") TestErrors.InvalidArgumentParameters parameters) { - super(errorCode, TestErrors.INVALID_ARGUMENT.name(), errorInstanceId, parameters); - } - } - } - - sealed interface TestOptionalBinaryResponse extends Closeable - permits TestOptionalBinaryResponse.Success, TestOptionalBinaryResponse.InvalidArgument { - @Override - default void close() throws IOException {} - - record Success(@JsonValue Optional value) implements TestOptionalBinaryResponse { - public Success { - Preconditions.checkArgumentNotNull(value, "value cannot be null"); - } - - @Override - public void close() throws IOException { - if (value.isPresent()) { - value.get().close(); - } - } - } - - final class InvalidArgument extends EndpointError - implements TestOptionalBinaryResponse { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - InvalidArgument( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") TestErrors.InvalidArgumentParameters parameters) { - super(errorCode, TestErrors.INVALID_ARGUMENT.name(), errorInstanceId, parameters); - } - } - } -} diff --git a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorServiceBlocking.java b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorServiceBlocking.java deleted file mode 100644 index 056d33312..000000000 --- a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorServiceBlocking.java +++ /dev/null @@ -1,479 +0,0 @@ -package dialogueendpointresulttypes.com.palantir.product; - -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.fasterxml.jackson.annotation.JsonValue; -import com.google.errorprone.annotations.CheckReturnValue; -import com.google.errorprone.annotations.MustBeClosed; -import com.palantir.conjure.java.lib.internal.ClientEndpoint; -import com.palantir.dialogue.Channel; -import com.palantir.dialogue.ConjureRuntime; -import com.palantir.dialogue.Deserializer; -import com.palantir.dialogue.DeserializerArgs; -import com.palantir.dialogue.DialogueService; -import com.palantir.dialogue.DialogueServiceFactory; -import com.palantir.dialogue.Endpoint; -import com.palantir.dialogue.EndpointChannel; -import com.palantir.dialogue.EndpointChannelFactory; -import com.palantir.dialogue.EndpointError; -import com.palantir.dialogue.PlainSerDe; -import com.palantir.dialogue.Request; -import com.palantir.dialogue.Serializer; -import com.palantir.dialogue.TypeMarker; -import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.Safe; -import com.palantir.tokens.auth.AuthHeader; -import java.io.Closeable; -import java.io.IOException; -import java.io.InputStream; -import java.lang.Boolean; -import java.lang.Override; -import java.lang.String; -import java.util.Optional; -import javax.annotation.processing.Generated; - -@Generated("com.palantir.conjure.java.services.dialogue.DialogueInterfaceGenerator") -@DialogueService(ErrorServiceBlocking.Factory.class) -public interface ErrorServiceBlocking { - /** @apiNote {@code POST /errors/basic} */ - @ClientEndpoint(method = "POST", path = "/errors/basic") - @CheckReturnValue - TestBasicErrorResponse testBasicError(AuthHeader authHeader, boolean shouldThrowError); - - /** @apiNote {@code POST /errors/imported} */ - @ClientEndpoint(method = "POST", path = "/errors/imported") - @CheckReturnValue - TestImportedErrorResponse testImportedError(AuthHeader authHeader, boolean shouldThrowError); - - /** @apiNote {@code POST /errors/multiple} */ - @ClientEndpoint(method = "POST", path = "/errors/multiple") - @CheckReturnValue - TestMultipleErrorsAndPackagesResponse testMultipleErrorsAndPackages( - AuthHeader authHeader, Optional errorToThrow); - - /** @apiNote {@code POST /errors/empty} */ - @ClientEndpoint(method = "POST", path = "/errors/empty") - @CheckReturnValue - TestEmptyBodyResponse testEmptyBody(AuthHeader authHeader, boolean shouldThrowError); - - /** @apiNote {@code POST /errors/binary} */ - @ClientEndpoint(method = "POST", path = "/errors/binary") - @CheckReturnValue - TestBinaryResponse testBinary(AuthHeader authHeader, boolean shouldThrowError); - - /** @apiNote {@code POST /errors/optional-binary} */ - @ClientEndpoint(method = "POST", path = "/errors/optional-binary") - @CheckReturnValue - TestOptionalBinaryResponse testOptionalBinary(AuthHeader authHeader, OptionalBinaryResponseMode mode); - - /** Creates a synchronous/blocking client for a ErrorService service. */ - static ErrorServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, ConjureRuntime _runtime) { - return new ErrorServiceBlocking() { - private final PlainSerDe _plainSerDe = _runtime.plainSerDe(); - - private final Serializer testBasicErrorSerializer = - _runtime.bodySerDe().serializer(new TypeMarker() {}); - - private final EndpointChannel testBasicErrorChannel = - _endpointChannelFactory.endpoint(DialogueErrorEndpoints.testBasicError); - - private final Deserializer testBasicErrorDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) - .error( - TestErrors.INVALID_ARGUMENT.name(), - new TypeMarker() {}) - .error( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG_ERR.name(), - new TypeMarker() {}) - .build()); - - private final Serializer testImportedErrorSerializer = - _runtime.bodySerDe().serializer(new TypeMarker() {}); - - private final EndpointChannel testImportedErrorChannel = - _endpointChannelFactory.endpoint(DialogueErrorEndpoints.testImportedError); - - private final Deserializer testImportedErrorDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) - .error( - EndpointSpecificErrors.ENDPOINT_ERROR.name(), - new TypeMarker() {}) - .build()); - - private final Serializer> testMultipleErrorsAndPackagesSerializer = - _runtime.bodySerDe().serializer(new TypeMarker>() {}); - - private final EndpointChannel testMultipleErrorsAndPackagesChannel = - _endpointChannelFactory.endpoint(DialogueErrorEndpoints.testMultipleErrorsAndPackages); - - private final Deserializer - testMultipleErrorsAndPackagesDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) - .error( - TestErrors.INVALID_ARGUMENT.name(), - new TypeMarker() {}) - .error( - TestErrors.NOT_FOUND.name(), - new TypeMarker() {}) - .error( - EndpointSpecificTwoErrors.DIFFERENT_NAMESPACE.name(), - new TypeMarker< - TestMultipleErrorsAndPackagesResponse.DifferentNamespace>() {}) - .error( - dialogueendpointresulttypes.com.palantir.another.EndpointSpecificErrors - .DIFFERENT_PACKAGE - .name(), - new TypeMarker() {}) - .error( - TestErrors.COMPLICATED_PARAMETERS.name(), - new TypeMarker< - TestMultipleErrorsAndPackagesResponse.ComplicatedParameters>() {}) - .build()); - - private final Serializer testEmptyBodySerializer = - _runtime.bodySerDe().serializer(new TypeMarker() {}); - - private final EndpointChannel testEmptyBodyChannel = - _endpointChannelFactory.endpoint(DialogueErrorEndpoints.testEmptyBody); - - private final Deserializer testEmptyBodyDeserializer = _runtime.bodySerDe() - .deserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) - .error( - TestErrors.INVALID_ARGUMENT.name(), - new TypeMarker() {}) - .build()); - - private final Serializer testBinarySerializer = - _runtime.bodySerDe().serializer(new TypeMarker() {}); - - private final EndpointChannel testBinaryChannel = - _endpointChannelFactory.endpoint(DialogueErrorEndpoints.testBinary); - - private final Deserializer testBinaryDeserializer = _runtime.bodySerDe() - .inputStreamDeserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) - .error( - TestErrors.INVALID_ARGUMENT.name(), - new TypeMarker() {}) - .build()); - - private final Serializer testOptionalBinarySerializer = - _runtime.bodySerDe().serializer(new TypeMarker() {}); - - private final EndpointChannel testOptionalBinaryChannel = - _endpointChannelFactory.endpoint(DialogueErrorEndpoints.testOptionalBinary); - - private final Deserializer testOptionalBinaryDeserializer = _runtime.bodySerDe() - .optionalInputStreamDeserializer(DeserializerArgs.builder() - .baseType(new TypeMarker<>() {}) - .success(new TypeMarker() {}) - .error( - TestErrors.INVALID_ARGUMENT.name(), - new TypeMarker() {}) - .build()); - - @Override - public TestBasicErrorResponse testBasicError(AuthHeader authHeader, boolean shouldThrowError) { - Request.Builder _request = Request.builder(); - _request.putHeaderParams("Authorization", authHeader.toString()); - _request.body(testBasicErrorSerializer.serialize(shouldThrowError)); - return _runtime.clients() - .callBlocking(testBasicErrorChannel, _request.build(), testBasicErrorDeserializer); - } - - @Override - public TestImportedErrorResponse testImportedError(AuthHeader authHeader, boolean shouldThrowError) { - Request.Builder _request = Request.builder(); - _request.putHeaderParams("Authorization", authHeader.toString()); - _request.body(testImportedErrorSerializer.serialize(shouldThrowError)); - return _runtime.clients() - .callBlocking(testImportedErrorChannel, _request.build(), testImportedErrorDeserializer); - } - - @Override - public TestMultipleErrorsAndPackagesResponse testMultipleErrorsAndPackages( - AuthHeader authHeader, Optional errorToThrow) { - Request.Builder _request = Request.builder(); - _request.putHeaderParams("Authorization", authHeader.toString()); - _request.body(testMultipleErrorsAndPackagesSerializer.serialize(errorToThrow)); - return _runtime.clients() - .callBlocking( - testMultipleErrorsAndPackagesChannel, - _request.build(), - testMultipleErrorsAndPackagesDeserializer); - } - - @Override - public TestEmptyBodyResponse testEmptyBody(AuthHeader authHeader, boolean shouldThrowError) { - Request.Builder _request = Request.builder(); - _request.putHeaderParams("Authorization", authHeader.toString()); - _request.body(testEmptyBodySerializer.serialize(shouldThrowError)); - return _runtime.clients() - .callBlocking(testEmptyBodyChannel, _request.build(), testEmptyBodyDeserializer); - } - - @Override - public TestBinaryResponse testBinary(AuthHeader authHeader, boolean shouldThrowError) { - Request.Builder _request = Request.builder(); - _request.putHeaderParams("Authorization", authHeader.toString()); - _request.body(testBinarySerializer.serialize(shouldThrowError)); - return _runtime.clients().callBlocking(testBinaryChannel, _request.build(), testBinaryDeserializer); - } - - @Override - public TestOptionalBinaryResponse testOptionalBinary( - AuthHeader authHeader, OptionalBinaryResponseMode mode) { - Request.Builder _request = Request.builder(); - _request.putHeaderParams("Authorization", authHeader.toString()); - _request.body(testOptionalBinarySerializer.serialize(mode)); - return _runtime.clients() - .callBlocking(testOptionalBinaryChannel, _request.build(), testOptionalBinaryDeserializer); - } - - @Override - public String toString() { - return "ErrorServiceBlocking{_endpointChannelFactory=" + _endpointChannelFactory + ", runtime=" - + _runtime + '}'; - } - }; - } - - /** Creates an asynchronous/non-blocking client for a ErrorService service. */ - static ErrorServiceBlocking of(Channel _channel, ConjureRuntime _runtime) { - if (_channel instanceof EndpointChannelFactory) { - return of((EndpointChannelFactory) _channel, _runtime); - } - return of( - new EndpointChannelFactory() { - @Override - public EndpointChannel endpoint(Endpoint endpoint) { - return _runtime.clients().bind(_channel, endpoint); - } - }, - _runtime); - } - - final class Factory implements DialogueServiceFactory { - @Override - public ErrorServiceBlocking create(EndpointChannelFactory endpointChannelFactory, ConjureRuntime runtime) { - return ErrorServiceBlocking.of(endpointChannelFactory, runtime); - } - } - - sealed interface TestBasicErrorResponse - permits TestBasicErrorResponse.Success, - TestBasicErrorResponse.InvalidArgument, - TestBasicErrorResponse.ConflictingCauseSafeArgErr { - record Success(@JsonValue String value) implements TestBasicErrorResponse { - public Success { - Preconditions.checkArgumentNotNull(value, "value cannot be null"); - } - } - - final class InvalidArgument extends EndpointError - implements TestBasicErrorResponse { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - InvalidArgument( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") TestErrors.InvalidArgumentParameters parameters) { - super(errorCode, TestErrors.INVALID_ARGUMENT.name(), errorInstanceId, parameters); - } - } - - final class ConflictingCauseSafeArgErr extends EndpointError - implements TestBasicErrorResponse { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - ConflictingCauseSafeArgErr( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") ConjureErrors.ConflictingCauseSafeArgErrParameters parameters) { - super(errorCode, ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG_ERR.name(), errorInstanceId, parameters); - } - } - } - - sealed interface TestImportedErrorResponse - permits TestImportedErrorResponse.Success, TestImportedErrorResponse.EndpointError { - record Success(@JsonValue String value) implements TestImportedErrorResponse { - public Success { - Preconditions.checkArgumentNotNull(value, "value cannot be null"); - } - } - - final class EndpointError - extends com.palantir.dialogue.EndpointError - implements TestImportedErrorResponse { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - EndpointError( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") EndpointSpecificErrors.EndpointErrorParameters parameters) { - super(errorCode, EndpointSpecificErrors.ENDPOINT_ERROR.name(), errorInstanceId, parameters); - } - } - } - - sealed interface TestMultipleErrorsAndPackagesResponse - permits TestMultipleErrorsAndPackagesResponse.Success, - TestMultipleErrorsAndPackagesResponse.InvalidArgument, - TestMultipleErrorsAndPackagesResponse.NotFound, - TestMultipleErrorsAndPackagesResponse.DifferentNamespace, - TestMultipleErrorsAndPackagesResponse.DifferentPackage, - TestMultipleErrorsAndPackagesResponse.ComplicatedParameters { - record Success(@JsonValue String value) implements TestMultipleErrorsAndPackagesResponse { - public Success { - Preconditions.checkArgumentNotNull(value, "value cannot be null"); - } - } - - final class InvalidArgument extends EndpointError - implements TestMultipleErrorsAndPackagesResponse { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - InvalidArgument( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") TestErrors.InvalidArgumentParameters parameters) { - super(errorCode, TestErrors.INVALID_ARGUMENT.name(), errorInstanceId, parameters); - } - } - - final class NotFound extends EndpointError - implements TestMultipleErrorsAndPackagesResponse { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - NotFound( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") TestErrors.NotFoundParameters parameters) { - super(errorCode, TestErrors.NOT_FOUND.name(), errorInstanceId, parameters); - } - } - - final class DifferentNamespace extends EndpointError - implements TestMultipleErrorsAndPackagesResponse { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - DifferentNamespace( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId) { - super( - errorCode, - EndpointSpecificTwoErrors.DIFFERENT_NAMESPACE.name(), - errorInstanceId, - new EndpointSpecificTwoErrors.DifferentNamespaceParameters()); - } - } - - final class DifferentPackage - extends EndpointError< - dialogueendpointresulttypes.com.palantir.another.EndpointSpecificErrors - .DifferentPackageParameters> - implements TestMultipleErrorsAndPackagesResponse { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - DifferentPackage( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId) { - super( - errorCode, - dialogueendpointresulttypes.com.palantir.another.EndpointSpecificErrors.DIFFERENT_PACKAGE - .name(), - errorInstanceId, - new dialogueendpointresulttypes.com.palantir.another.EndpointSpecificErrors - .DifferentPackageParameters()); - } - } - - final class ComplicatedParameters extends EndpointError - implements TestMultipleErrorsAndPackagesResponse { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - ComplicatedParameters( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") TestErrors.ComplicatedParametersParameters parameters) { - super(errorCode, TestErrors.COMPLICATED_PARAMETERS.name(), errorInstanceId, parameters); - } - } - } - - sealed interface TestEmptyBodyResponse - permits TestEmptyBodyResponse.Success, TestEmptyBodyResponse.InvalidArgument { - record Success() implements TestEmptyBodyResponse {} - - final class InvalidArgument extends EndpointError - implements TestEmptyBodyResponse { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - InvalidArgument( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") TestErrors.InvalidArgumentParameters parameters) { - super(errorCode, TestErrors.INVALID_ARGUMENT.name(), errorInstanceId, parameters); - } - } - } - - sealed interface TestBinaryResponse extends Closeable - permits TestBinaryResponse.Success, TestBinaryResponse.InvalidArgument { - @Override - default void close() throws IOException {} - - record Success(@MustBeClosed @JsonValue InputStream value) implements TestBinaryResponse { - public Success { - Preconditions.checkArgumentNotNull(value, "value cannot be null"); - } - - @Override - public void close() throws IOException { - value.close(); - } - } - - final class InvalidArgument extends EndpointError - implements TestBinaryResponse { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - InvalidArgument( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") TestErrors.InvalidArgumentParameters parameters) { - super(errorCode, TestErrors.INVALID_ARGUMENT.name(), errorInstanceId, parameters); - } - } - } - - sealed interface TestOptionalBinaryResponse extends Closeable - permits TestOptionalBinaryResponse.Success, TestOptionalBinaryResponse.InvalidArgument { - @Override - default void close() throws IOException {} - - record Success(@JsonValue Optional value) implements TestOptionalBinaryResponse { - public Success { - Preconditions.checkArgumentNotNull(value, "value cannot be null"); - } - - @Override - public void close() throws IOException { - if (value.isPresent()) { - value.get().close(); - } - } - } - - final class InvalidArgument extends EndpointError - implements TestOptionalBinaryResponse { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - InvalidArgument( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") TestErrors.InvalidArgumentParameters parameters) { - super(errorCode, TestErrors.INVALID_ARGUMENT.name(), errorInstanceId, parameters); - } - } - } -} diff --git a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorServiceEndpoints.java b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorServiceEndpoints.java deleted file mode 100644 index e4a94ff84..000000000 --- a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/ErrorServiceEndpoints.java +++ /dev/null @@ -1,345 +0,0 @@ -package dialogueendpointresulttypes.com.palantir.product; - -import com.google.common.collect.ImmutableList; -import com.palantir.conjure.java.undertow.lib.BinaryResponseBody; -import com.palantir.conjure.java.undertow.lib.Deserializer; -import com.palantir.conjure.java.undertow.lib.Endpoint; -import com.palantir.conjure.java.undertow.lib.Serializer; -import com.palantir.conjure.java.undertow.lib.TypeMarker; -import com.palantir.conjure.java.undertow.lib.UndertowRuntime; -import com.palantir.conjure.java.undertow.lib.UndertowService; -import com.palantir.tokens.auth.AuthHeader; -import io.undertow.server.HttpHandler; -import io.undertow.server.HttpServerExchange; -import io.undertow.util.HttpString; -import io.undertow.util.Methods; -import io.undertow.util.StatusCodes; -import java.io.IOException; -import java.util.List; -import java.util.Optional; -import javax.annotation.processing.Generated; - -@Generated("com.palantir.conjure.java.services.UndertowServiceHandlerGenerator") -public final class ErrorServiceEndpoints implements UndertowService { - private final ErrorService delegate; - - private ErrorServiceEndpoints(ErrorService delegate) { - this.delegate = delegate; - } - - public static UndertowService of(ErrorService delegate) { - return new ErrorServiceEndpoints(delegate); - } - - @Override - public List endpoints(UndertowRuntime runtime) { - return ImmutableList.of( - new TestBasicErrorEndpoint(runtime, delegate), - new TestImportedErrorEndpoint(runtime, delegate), - new TestMultipleErrorsAndPackagesEndpoint(runtime, delegate), - new TestEmptyBodyEndpoint(runtime, delegate), - new TestBinaryEndpoint(runtime, delegate), - new TestOptionalBinaryEndpoint(runtime, delegate)); - } - - private static final class TestBasicErrorEndpoint implements HttpHandler, Endpoint { - private final UndertowRuntime runtime; - - private final ErrorService delegate; - - private final Deserializer deserializer; - - private final Serializer serializer; - - TestBasicErrorEndpoint(UndertowRuntime runtime, ErrorService delegate) { - this.runtime = runtime; - this.delegate = delegate; - this.deserializer = runtime.bodySerDe().deserializer(new TypeMarker() {}, this); - this.serializer = runtime.bodySerDe().serializer(new TypeMarker() {}, this); - } - - @Override - public void handleRequest(HttpServerExchange exchange) - throws IOException, TestServerErrors.InvalidArgument, ConjureServerErrors.ConflictingCauseSafeArgErr { - AuthHeader authHeader = runtime.auth().header(exchange); - Boolean shouldThrowError = deserializer.deserialize(exchange); - String result = delegate.testBasicError(authHeader, shouldThrowError); - serializer.serialize(result, exchange); - } - - @Override - public HttpString method() { - return Methods.POST; - } - - @Override - public String template() { - return "/errors/basic"; - } - - @Override - public String serviceName() { - return "ErrorService"; - } - - @Override - public String name() { - return "testBasicError"; - } - - @Override - public HttpHandler handler() { - return this; - } - } - - private static final class TestImportedErrorEndpoint implements HttpHandler, Endpoint { - private final UndertowRuntime runtime; - - private final ErrorService delegate; - - private final Deserializer deserializer; - - private final Serializer serializer; - - TestImportedErrorEndpoint(UndertowRuntime runtime, ErrorService delegate) { - this.runtime = runtime; - this.delegate = delegate; - this.deserializer = runtime.bodySerDe().deserializer(new TypeMarker() {}, this); - this.serializer = runtime.bodySerDe().serializer(new TypeMarker() {}, this); - } - - @Override - public void handleRequest(HttpServerExchange exchange) - throws IOException, EndpointSpecificServerErrors.EndpointError { - AuthHeader authHeader = runtime.auth().header(exchange); - Boolean shouldThrowError = deserializer.deserialize(exchange); - String result = delegate.testImportedError(authHeader, shouldThrowError); - serializer.serialize(result, exchange); - } - - @Override - public HttpString method() { - return Methods.POST; - } - - @Override - public String template() { - return "/errors/imported"; - } - - @Override - public String serviceName() { - return "ErrorService"; - } - - @Override - public String name() { - return "testImportedError"; - } - - @Override - public HttpHandler handler() { - return this; - } - } - - private static final class TestMultipleErrorsAndPackagesEndpoint implements HttpHandler, Endpoint { - private final UndertowRuntime runtime; - - private final ErrorService delegate; - - private final Deserializer> deserializer; - - private final Serializer serializer; - - TestMultipleErrorsAndPackagesEndpoint(UndertowRuntime runtime, ErrorService delegate) { - this.runtime = runtime; - this.delegate = delegate; - this.deserializer = runtime.bodySerDe().deserializer(new TypeMarker>() {}, this); - this.serializer = runtime.bodySerDe().serializer(new TypeMarker() {}, this); - } - - @Override - public void handleRequest(HttpServerExchange exchange) - throws IOException, TestServerErrors.InvalidArgument, TestServerErrors.NotFound, - EndpointSpecificTwoServerErrors.DifferentNamespace, - dialogueendpointresulttypes.com.palantir.another.EndpointSpecificServerErrors.DifferentPackage, - TestServerErrors.ComplicatedParameters { - AuthHeader authHeader = runtime.auth().header(exchange); - Optional errorToThrow = deserializer.deserialize(exchange); - String result = delegate.testMultipleErrorsAndPackages(authHeader, errorToThrow); - serializer.serialize(result, exchange); - } - - @Override - public HttpString method() { - return Methods.POST; - } - - @Override - public String template() { - return "/errors/multiple"; - } - - @Override - public String serviceName() { - return "ErrorService"; - } - - @Override - public String name() { - return "testMultipleErrorsAndPackages"; - } - - @Override - public HttpHandler handler() { - return this; - } - } - - private static final class TestEmptyBodyEndpoint implements HttpHandler, Endpoint { - private final UndertowRuntime runtime; - - private final ErrorService delegate; - - private final Deserializer deserializer; - - TestEmptyBodyEndpoint(UndertowRuntime runtime, ErrorService delegate) { - this.runtime = runtime; - this.delegate = delegate; - this.deserializer = runtime.bodySerDe().deserializer(new TypeMarker() {}, this); - } - - @Override - public void handleRequest(HttpServerExchange exchange) throws IOException, TestServerErrors.InvalidArgument { - AuthHeader authHeader = runtime.auth().header(exchange); - Boolean shouldThrowError = deserializer.deserialize(exchange); - delegate.testEmptyBody(authHeader, shouldThrowError); - exchange.setStatusCode(StatusCodes.NO_CONTENT); - } - - @Override - public HttpString method() { - return Methods.POST; - } - - @Override - public String template() { - return "/errors/empty"; - } - - @Override - public String serviceName() { - return "ErrorService"; - } - - @Override - public String name() { - return "testEmptyBody"; - } - - @Override - public HttpHandler handler() { - return this; - } - } - - private static final class TestBinaryEndpoint implements HttpHandler, Endpoint { - private final UndertowRuntime runtime; - - private final ErrorService delegate; - - private final Deserializer deserializer; - - TestBinaryEndpoint(UndertowRuntime runtime, ErrorService delegate) { - this.runtime = runtime; - this.delegate = delegate; - this.deserializer = runtime.bodySerDe().deserializer(new TypeMarker() {}, this); - } - - @Override - public void handleRequest(HttpServerExchange exchange) throws IOException, TestServerErrors.InvalidArgument { - AuthHeader authHeader = runtime.auth().header(exchange); - Boolean shouldThrowError = deserializer.deserialize(exchange); - BinaryResponseBody result = delegate.testBinary(authHeader, shouldThrowError); - runtime.bodySerDe().serialize(result, exchange); - } - - @Override - public HttpString method() { - return Methods.POST; - } - - @Override - public String template() { - return "/errors/binary"; - } - - @Override - public String serviceName() { - return "ErrorService"; - } - - @Override - public String name() { - return "testBinary"; - } - - @Override - public HttpHandler handler() { - return this; - } - } - - private static final class TestOptionalBinaryEndpoint implements HttpHandler, Endpoint { - private final UndertowRuntime runtime; - - private final ErrorService delegate; - - private final Deserializer deserializer; - - TestOptionalBinaryEndpoint(UndertowRuntime runtime, ErrorService delegate) { - this.runtime = runtime; - this.delegate = delegate; - this.deserializer = runtime.bodySerDe().deserializer(new TypeMarker() {}, this); - } - - @Override - public void handleRequest(HttpServerExchange exchange) throws IOException, TestServerErrors.InvalidArgument { - AuthHeader authHeader = runtime.auth().header(exchange); - OptionalBinaryResponseMode mode = deserializer.deserialize(exchange); - Optional result = delegate.testOptionalBinary(authHeader, mode); - if (result.isPresent()) { - runtime.bodySerDe().serialize(result.get(), exchange); - } else { - exchange.setStatusCode(StatusCodes.NO_CONTENT); - } - } - - @Override - public HttpString method() { - return Methods.POST; - } - - @Override - public String template() { - return "/errors/optional-binary"; - } - - @Override - public String serviceName() { - return "ErrorService"; - } - - @Override - public String name() { - return "testOptionalBinary"; - } - - @Override - public HttpHandler handler() { - return this; - } - } -} diff --git a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/TestErrors.java b/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/TestErrors.java deleted file mode 100644 index 0fbc0db70..000000000 --- a/conjure-java-core/src/integrationInput/java/dialogueendpointresulttypes/com/palantir/product/TestErrors.java +++ /dev/null @@ -1,157 +0,0 @@ -package dialogueendpointresulttypes.com.palantir.product; - -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.palantir.conjure.java.api.errors.AbstractSerializableError; -import com.palantir.conjure.java.api.errors.ErrorType; -import com.palantir.conjure.java.api.errors.RemoteException; -import com.palantir.conjure.java.api.errors.SerializableError; -import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.Safe; -import com.palantir.logsafe.Unsafe; -import java.util.Map; -import java.util.Objects; -import javax.annotation.processing.Generated; - -@Generated("com.palantir.conjure.java.types.ErrorGenerator") -public final class TestErrors { - public static final ErrorType COMPLICATED_PARAMETERS = - ErrorType.create(ErrorType.Code.INTERNAL, "Test:ComplicatedParameters"); - - public static final ErrorType INVALID_ARGUMENT = - ErrorType.create(ErrorType.Code.INVALID_ARGUMENT, "Test:InvalidArgument"); - - public static final ErrorType NOT_FOUND = ErrorType.create(ErrorType.Code.NOT_FOUND, "Test:NotFound"); - - private TestErrors() {} - - /** Returns true if the {@link RemoteException} is named Test:ComplicatedParameters */ - public static boolean isComplicatedParameters(RemoteException remoteException) { - Preconditions.checkNotNull(remoteException, "remote exception must not be null"); - return COMPLICATED_PARAMETERS.name().equals(remoteException.getError().errorName()); - } - - /** Returns true if the {@link RemoteException} is named Test:InvalidArgument */ - public static boolean isInvalidArgument(RemoteException remoteException) { - Preconditions.checkNotNull(remoteException, "remote exception must not be null"); - return INVALID_ARGUMENT.name().equals(remoteException.getError().errorName()); - } - - /** Returns true if the {@link RemoteException} is named Test:NotFound */ - public static boolean isNotFound(RemoteException remoteException) { - Preconditions.checkNotNull(remoteException, "remote exception must not be null"); - return NOT_FOUND.name().equals(remoteException.getError().errorName()); - } - - public static record ComplicatedParametersParameters( - @JsonProperty("complicatedObjectMap") @Safe Map complicatedObjectMap) {} - - public static record InvalidArgumentParameters( - @JsonProperty("field") @Safe String field, @JsonProperty("value") @Unsafe String value) {} - - public static record NotFoundParameters(@JsonProperty("resource") @Safe String resource) {} - - public static final class ComplicatedParametersSerializableError - extends AbstractSerializableError { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - ComplicatedParametersSerializableError( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorName") @Safe String errorName, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") ComplicatedParametersParameters parameters) { - super(errorCode, errorName, errorInstanceId, parameters); - } - - public SerializableError toSerializableError() { - return SerializableError.builder() - .putParameters( - "complicatedObjectMap", - Objects.toString(parameters().complicatedObjectMap())) - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()) - .build(); - } - } - - public static final class InvalidArgumentSerializableError - extends AbstractSerializableError { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - InvalidArgumentSerializableError( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorName") @Safe String errorName, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") InvalidArgumentParameters parameters) { - super(errorCode, errorName, errorInstanceId, parameters); - } - - public SerializableError toSerializableError() { - return SerializableError.builder() - .putParameters("field", Objects.toString(parameters().field())) - .putParameters("value", Objects.toString(parameters().value())) - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()) - .build(); - } - } - - public static final class NotFoundSerializableError extends AbstractSerializableError { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - NotFoundSerializableError( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorName") @Safe String errorName, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") NotFoundParameters parameters) { - super(errorCode, errorName, errorInstanceId, parameters); - } - - public SerializableError toSerializableError() { - return SerializableError.builder() - .putParameters("resource", Objects.toString(parameters().resource())) - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()) - .build(); - } - } - - public static final class ComplicatedParametersException extends RemoteException { - private ComplicatedParametersSerializableError error; - - public ComplicatedParametersException(ComplicatedParametersSerializableError error, int status) { - super(error.toSerializableError(), status); - this.error = error; - } - - public ComplicatedParametersSerializableError error() { - return error; - } - } - - public static final class InvalidArgumentException extends RemoteException { - private InvalidArgumentSerializableError error; - - public InvalidArgumentException(InvalidArgumentSerializableError error, int status) { - super(error.toSerializableError(), status); - this.error = error; - } - - public InvalidArgumentSerializableError error() { - return error; - } - } - - public static final class NotFoundException extends RemoteException { - private NotFoundSerializableError error; - - public NotFoundException(NotFoundSerializableError error, int status) { - super(error.toSerializableError(), status); - this.error = error; - } - - public NotFoundSerializableError error() { - return error; - } - } -} diff --git a/conjure-java-core/src/integrationInput/java/errors/com/palantir/another/ConjureErrors.java b/conjure-java-core/src/integrationInput/java/errors/com/palantir/another/ConjureErrors.java index 9e2bfa22c..c106c2f1d 100644 --- a/conjure-java-core/src/integrationInput/java/errors/com/palantir/another/ConjureErrors.java +++ b/conjure-java-core/src/integrationInput/java/errors/com/palantir/another/ConjureErrors.java @@ -1,14 +1,9 @@ package errors.com.palantir.another; -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.palantir.conjure.java.api.errors.AbstractSerializableError; import com.palantir.conjure.java.api.errors.ErrorType; import com.palantir.conjure.java.api.errors.RemoteException; -import com.palantir.conjure.java.api.errors.SerializableError; import com.palantir.conjure.java.api.errors.ServiceException; import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.Safe; import javax.annotation.Nullable; import javax.annotation.processing.Generated; import org.jetbrains.annotations.Contract; @@ -46,39 +41,4 @@ public static boolean isDifferentPackageError(RemoteException remoteException) { Preconditions.checkNotNull(remoteException, "remote exception must not be null"); return DIFFERENT_PACKAGE_ERROR.name().equals(remoteException.getError().errorName()); } - - public static record DifferentPackageErrorParameters() {} - - public static final class DifferentPackageErrorSerializableError - extends AbstractSerializableError { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - DifferentPackageErrorSerializableError( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorName") @Safe String errorName, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") DifferentPackageErrorParameters parameters) { - super(errorCode, errorName, errorInstanceId, parameters); - } - - public SerializableError toSerializableError() { - return SerializableError.builder() - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()) - .build(); - } - } - - public static final class DifferentPackageErrorException extends RemoteException { - private DifferentPackageErrorSerializableError error; - - public DifferentPackageErrorException(DifferentPackageErrorSerializableError error, int status) { - super(error.toSerializableError(), status); - this.error = error; - } - - public DifferentPackageErrorSerializableError error() { - return error; - } - } } diff --git a/conjure-java-core/src/integrationInput/java/errors/com/palantir/another/ConjureJavaOtherErrors.java b/conjure-java-core/src/integrationInput/java/errors/com/palantir/another/ConjureJavaOtherErrors.java index c85e1c731..01dacd9c0 100644 --- a/conjure-java-core/src/integrationInput/java/errors/com/palantir/another/ConjureJavaOtherErrors.java +++ b/conjure-java-core/src/integrationInput/java/errors/com/palantir/another/ConjureJavaOtherErrors.java @@ -1,14 +1,9 @@ package errors.com.palantir.another; -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.palantir.conjure.java.api.errors.AbstractSerializableError; import com.palantir.conjure.java.api.errors.ErrorType; import com.palantir.conjure.java.api.errors.RemoteException; -import com.palantir.conjure.java.api.errors.SerializableError; import com.palantir.conjure.java.api.errors.ServiceException; import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.Safe; import javax.annotation.Nullable; import javax.annotation.processing.Generated; import org.jetbrains.annotations.Contract; @@ -46,39 +41,4 @@ public static boolean isJavaCompilationFailed(RemoteException remoteException) { Preconditions.checkNotNull(remoteException, "remote exception must not be null"); return JAVA_COMPILATION_FAILED.name().equals(remoteException.getError().errorName()); } - - public static record JavaCompilationFailedParameters() {} - - public static final class JavaCompilationFailedSerializableError - extends AbstractSerializableError { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - JavaCompilationFailedSerializableError( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorName") @Safe String errorName, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") JavaCompilationFailedParameters parameters) { - super(errorCode, errorName, errorInstanceId, parameters); - } - - public SerializableError toSerializableError() { - return SerializableError.builder() - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()) - .build(); - } - } - - public static final class JavaCompilationFailedException extends RemoteException { - private JavaCompilationFailedSerializableError error; - - public JavaCompilationFailedException(JavaCompilationFailedSerializableError error, int status) { - super(error.toSerializableError(), status); - this.error = error; - } - - public JavaCompilationFailedSerializableError error() { - return error; - } - } } diff --git a/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureErrors.java b/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureErrors.java index 2037b9e2f..25079e171 100644 --- a/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureErrors.java +++ b/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureErrors.java @@ -1,18 +1,13 @@ package errors.com.palantir.product; -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.palantir.conjure.java.api.errors.AbstractSerializableError; import com.palantir.conjure.java.api.errors.ErrorType; import com.palantir.conjure.java.api.errors.RemoteException; -import com.palantir.conjure.java.api.errors.SerializableError; import com.palantir.conjure.java.api.errors.ServiceException; import com.palantir.logsafe.Preconditions; import com.palantir.logsafe.Safe; import com.palantir.logsafe.SafeArg; import com.palantir.logsafe.Unsafe; import com.palantir.logsafe.UnsafeArg; -import java.util.Objects; import javax.annotation.Nullable; import javax.annotation.processing.Generated; import org.jetbrains.annotations.Contract; @@ -335,239 +330,4 @@ public static boolean isInvalidTypeDefinition(RemoteException remoteException) { Preconditions.checkNotNull(remoteException, "remote exception must not be null"); return INVALID_TYPE_DEFINITION.name().equals(remoteException.getError().errorName()); } - - public static record ConflictingCauseSafeArgParameters( - @JsonProperty("cause") @Safe String cause_, @JsonProperty("shouldThrow") @Safe boolean shouldThrow_) {} - - public static record ConflictingCauseUnsafeArgParameters( - @JsonProperty("cause") @Unsafe String cause_, @JsonProperty("shouldThrow") @Unsafe boolean shouldThrow_) {} - - public static record ErrorWithComplexArgsParameters( - @JsonProperty("primitiveExample") @Safe PrimitiveExample primitiveExample, - @JsonProperty("collectionExample") @Safe CollectionExample collectionExample, - @JsonProperty("nestedCollectionExample") @Safe NestedCollectionExample nestedCollectionExample, - @JsonProperty("optionalExample") @Safe OptionalExample optionalExample, - @JsonProperty("objectReference") @Safe ObjectReference objectReference, - @JsonProperty("unionExample") @Safe UnionExample unionExample, - @JsonProperty("enumExample") @Safe EnumExample enumExample, - @JsonProperty("stringAlias") @Safe StringAliasEx stringAlias, - @JsonProperty("optionalAlias") @Safe OptionalAlias optionalAlias, - @JsonProperty("collectionAlias") @Safe CollectionAlias collectionAlias, - @JsonProperty("nestedAlias") @Safe NestedAlias nestedAlias, - @JsonProperty("externalExample") @Safe ExternalExample externalExample, - @JsonProperty("anyExample") @Safe AnyExample anyExample, - @JsonProperty("emptyObject") @Safe EmptyObject emptyObject, - @JsonProperty("complexExample") @Safe ComplexExample complexExample, - @JsonProperty("safetyExample") @Unsafe SafetyExample safetyExample) {} - - /** - * @param serviceName Name of the invalid service definition. - * @param serviceDef Details of the invalid service definition. - */ - public static record InvalidServiceDefinitionParameters( - @JsonProperty("serviceName") @Safe String serviceName, - @JsonProperty("serviceDef") @Unsafe Object serviceDef) {} - - public static record InvalidTypeDefinitionParameters( - @JsonProperty("typeName") @Safe String typeName, @JsonProperty("typeDef") @Unsafe Object typeDef) {} - - public static final class ConflictingCauseSafeArgSerializableError - extends AbstractSerializableError { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - ConflictingCauseSafeArgSerializableError( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorName") @Safe String errorName, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") ConflictingCauseSafeArgParameters parameters) { - super(errorCode, errorName, errorInstanceId, parameters); - } - - public SerializableError toSerializableError() { - return SerializableError.builder() - .putParameters("cause", Objects.toString(parameters().cause_())) - .putParameters("shouldThrow", Objects.toString(parameters().shouldThrow_())) - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()) - .build(); - } - } - - public static final class ConflictingCauseUnsafeArgSerializableError - extends AbstractSerializableError { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - ConflictingCauseUnsafeArgSerializableError( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorName") @Safe String errorName, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") ConflictingCauseUnsafeArgParameters parameters) { - super(errorCode, errorName, errorInstanceId, parameters); - } - - public SerializableError toSerializableError() { - return SerializableError.builder() - .putParameters("cause", Objects.toString(parameters().cause_())) - .putParameters("shouldThrow", Objects.toString(parameters().shouldThrow_())) - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()) - .build(); - } - } - - public static final class ErrorWithComplexArgsSerializableError - extends AbstractSerializableError { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - ErrorWithComplexArgsSerializableError( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorName") @Safe String errorName, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") ErrorWithComplexArgsParameters parameters) { - super(errorCode, errorName, errorInstanceId, parameters); - } - - public SerializableError toSerializableError() { - return SerializableError.builder() - .putParameters( - "primitiveExample", Objects.toString(parameters().primitiveExample())) - .putParameters( - "collectionExample", Objects.toString(parameters().collectionExample())) - .putParameters( - "nestedCollectionExample", - Objects.toString(parameters().nestedCollectionExample())) - .putParameters( - "optionalExample", Objects.toString(parameters().optionalExample())) - .putParameters( - "objectReference", Objects.toString(parameters().objectReference())) - .putParameters("unionExample", Objects.toString(parameters().unionExample())) - .putParameters("enumExample", Objects.toString(parameters().enumExample())) - .putParameters("stringAlias", Objects.toString(parameters().stringAlias())) - .putParameters( - "optionalAlias", Objects.toString(parameters().optionalAlias())) - .putParameters( - "collectionAlias", Objects.toString(parameters().collectionAlias())) - .putParameters("nestedAlias", Objects.toString(parameters().nestedAlias())) - .putParameters( - "externalExample", Objects.toString(parameters().externalExample())) - .putParameters("anyExample", Objects.toString(parameters().anyExample())) - .putParameters("emptyObject", Objects.toString(parameters().emptyObject())) - .putParameters( - "complexExample", Objects.toString(parameters().complexExample())) - .putParameters( - "safetyExample", Objects.toString(parameters().safetyExample())) - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()) - .build(); - } - } - - public static final class InvalidServiceDefinitionSerializableError - extends AbstractSerializableError { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - InvalidServiceDefinitionSerializableError( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorName") @Safe String errorName, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") InvalidServiceDefinitionParameters parameters) { - super(errorCode, errorName, errorInstanceId, parameters); - } - - public SerializableError toSerializableError() { - return SerializableError.builder() - .putParameters("serviceName", Objects.toString(parameters().serviceName())) - .putParameters("serviceDef", Objects.toString(parameters().serviceDef())) - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()) - .build(); - } - } - - public static final class InvalidTypeDefinitionSerializableError - extends AbstractSerializableError { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - InvalidTypeDefinitionSerializableError( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorName") @Safe String errorName, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") InvalidTypeDefinitionParameters parameters) { - super(errorCode, errorName, errorInstanceId, parameters); - } - - public SerializableError toSerializableError() { - return SerializableError.builder() - .putParameters("typeName", Objects.toString(parameters().typeName())) - .putParameters("typeDef", Objects.toString(parameters().typeDef())) - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()) - .build(); - } - } - - public static final class ConflictingCauseSafeArgException extends RemoteException { - private ConflictingCauseSafeArgSerializableError error; - - public ConflictingCauseSafeArgException(ConflictingCauseSafeArgSerializableError error, int status) { - super(error.toSerializableError(), status); - this.error = error; - } - - public ConflictingCauseSafeArgSerializableError error() { - return error; - } - } - - public static final class ConflictingCauseUnsafeArgException extends RemoteException { - private ConflictingCauseUnsafeArgSerializableError error; - - public ConflictingCauseUnsafeArgException(ConflictingCauseUnsafeArgSerializableError error, int status) { - super(error.toSerializableError(), status); - this.error = error; - } - - public ConflictingCauseUnsafeArgSerializableError error() { - return error; - } - } - - public static final class ErrorWithComplexArgsException extends RemoteException { - private ErrorWithComplexArgsSerializableError error; - - public ErrorWithComplexArgsException(ErrorWithComplexArgsSerializableError error, int status) { - super(error.toSerializableError(), status); - this.error = error; - } - - public ErrorWithComplexArgsSerializableError error() { - return error; - } - } - - public static final class InvalidServiceDefinitionException extends RemoteException { - private InvalidServiceDefinitionSerializableError error; - - public InvalidServiceDefinitionException(InvalidServiceDefinitionSerializableError error, int status) { - super(error.toSerializableError(), status); - this.error = error; - } - - public InvalidServiceDefinitionSerializableError error() { - return error; - } - } - - public static final class InvalidTypeDefinitionException extends RemoteException { - private InvalidTypeDefinitionSerializableError error; - - public InvalidTypeDefinitionException(InvalidTypeDefinitionSerializableError error, int status) { - super(error.toSerializableError(), status); - this.error = error; - } - - public InvalidTypeDefinitionSerializableError error() { - return error; - } - } } diff --git a/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureJavaErrors.java b/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureJavaErrors.java index 852719463..32adada3c 100644 --- a/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureJavaErrors.java +++ b/conjure-java-core/src/integrationInput/java/errors/com/palantir/product/ConjureJavaErrors.java @@ -1,14 +1,9 @@ package errors.com.palantir.product; -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.palantir.conjure.java.api.errors.AbstractSerializableError; import com.palantir.conjure.java.api.errors.ErrorType; import com.palantir.conjure.java.api.errors.RemoteException; -import com.palantir.conjure.java.api.errors.SerializableError; import com.palantir.conjure.java.api.errors.ServiceException; import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.Safe; import javax.annotation.Nullable; import javax.annotation.processing.Generated; import org.jetbrains.annotations.Contract; @@ -46,39 +41,4 @@ public static boolean isJavaCompilationFailed(RemoteException remoteException) { Preconditions.checkNotNull(remoteException, "remote exception must not be null"); return JAVA_COMPILATION_FAILED.name().equals(remoteException.getError().errorName()); } - - public static record JavaCompilationFailedParameters() {} - - public static final class JavaCompilationFailedSerializableError - extends AbstractSerializableError { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - JavaCompilationFailedSerializableError( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorName") @Safe String errorName, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") JavaCompilationFailedParameters parameters) { - super(errorCode, errorName, errorInstanceId, parameters); - } - - public SerializableError toSerializableError() { - return SerializableError.builder() - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()) - .build(); - } - } - - public static final class JavaCompilationFailedException extends RemoteException { - private JavaCompilationFailedSerializableError error; - - public JavaCompilationFailedException(JavaCompilationFailedSerializableError error, int status) { - super(error.toSerializableError(), status); - this.error = error; - } - - public JavaCompilationFailedSerializableError error() { - return error; - } - } } diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/another/EndpointSpecificErrors.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/another/EndpointSpecificErrors.java index 0082660cf..5ed9d792f 100644 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/another/EndpointSpecificErrors.java +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/another/EndpointSpecificErrors.java @@ -1,13 +1,8 @@ package undertow.com.palantir.another; -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.palantir.conjure.java.api.errors.AbstractSerializableError; import com.palantir.conjure.java.api.errors.ErrorType; import com.palantir.conjure.java.api.errors.RemoteException; -import com.palantir.conjure.java.api.errors.SerializableError; import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.Safe; import javax.annotation.processing.Generated; @Generated("com.palantir.conjure.java.types.ErrorGenerator") @@ -23,39 +18,4 @@ public static boolean isDifferentPackage(RemoteException remoteException) { Preconditions.checkNotNull(remoteException, "remote exception must not be null"); return DIFFERENT_PACKAGE.name().equals(remoteException.getError().errorName()); } - - public static record DifferentPackageParameters() {} - - public static final class DifferentPackageSerializableError - extends AbstractSerializableError { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - DifferentPackageSerializableError( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorName") @Safe String errorName, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") DifferentPackageParameters parameters) { - super(errorCode, errorName, errorInstanceId, parameters); - } - - public SerializableError toSerializableError() { - return SerializableError.builder() - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()) - .build(); - } - } - - public static final class DifferentPackageException extends RemoteException { - private DifferentPackageSerializableError error; - - public DifferentPackageException(DifferentPackageSerializableError error, int status) { - super(error.toSerializableError(), status); - this.error = error; - } - - public DifferentPackageSerializableError error() { - return error; - } - } } diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ConjureErrors.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ConjureErrors.java index 6c87b69b2..68d0fcf8f 100644 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ConjureErrors.java +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/ConjureErrors.java @@ -1,14 +1,8 @@ package undertow.com.palantir.product; -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.palantir.conjure.java.api.errors.AbstractSerializableError; import com.palantir.conjure.java.api.errors.ErrorType; import com.palantir.conjure.java.api.errors.RemoteException; -import com.palantir.conjure.java.api.errors.SerializableError; import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.Safe; -import java.util.Objects; import javax.annotation.processing.Generated; @Generated("com.palantir.conjure.java.types.ErrorGenerator") @@ -26,42 +20,4 @@ public static boolean isConflictingCauseSafeArgErr(RemoteException remoteExcepti .name() .equals(remoteException.getError().errorName()); } - - public static record ConflictingCauseSafeArgErrParameters( - @JsonProperty("cause") @Safe String cause_, @JsonProperty("shouldThrow") @Safe boolean shouldThrow_) {} - - public static final class ConflictingCauseSafeArgErrSerializableError - extends AbstractSerializableError { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - ConflictingCauseSafeArgErrSerializableError( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorName") @Safe String errorName, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") ConflictingCauseSafeArgErrParameters parameters) { - super(errorCode, errorName, errorInstanceId, parameters); - } - - public SerializableError toSerializableError() { - return SerializableError.builder() - .putParameters("cause", Objects.toString(parameters().cause_())) - .putParameters("shouldThrow", Objects.toString(parameters().shouldThrow_())) - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()) - .build(); - } - } - - public static final class ConflictingCauseSafeArgErrException extends RemoteException { - private ConflictingCauseSafeArgErrSerializableError error; - - public ConflictingCauseSafeArgErrException(ConflictingCauseSafeArgErrSerializableError error, int status) { - super(error.toSerializableError(), status); - this.error = error; - } - - public ConflictingCauseSafeArgErrSerializableError error() { - return error; - } - } } diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EndpointSpecificErrors.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EndpointSpecificErrors.java index a39c6e6dc..60616a273 100644 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EndpointSpecificErrors.java +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EndpointSpecificErrors.java @@ -1,15 +1,8 @@ package undertow.com.palantir.product; -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.palantir.conjure.java.api.errors.AbstractSerializableError; import com.palantir.conjure.java.api.errors.ErrorType; import com.palantir.conjure.java.api.errors.RemoteException; -import com.palantir.conjure.java.api.errors.SerializableError; import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.Safe; -import com.palantir.logsafe.Unsafe; -import java.util.Objects; import javax.annotation.processing.Generated; @Generated("com.palantir.conjure.java.types.ErrorGenerator") @@ -25,42 +18,4 @@ public static boolean isEndpointError(RemoteException remoteException) { Preconditions.checkNotNull(remoteException, "remote exception must not be null"); return ENDPOINT_ERROR.name().equals(remoteException.getError().errorName()); } - - public static record EndpointErrorParameters( - @JsonProperty("typeName") @Safe String typeName, @JsonProperty("typeDef") @Unsafe Object typeDef) {} - - public static final class EndpointErrorSerializableError - extends AbstractSerializableError { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - EndpointErrorSerializableError( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorName") @Safe String errorName, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") EndpointErrorParameters parameters) { - super(errorCode, errorName, errorInstanceId, parameters); - } - - public SerializableError toSerializableError() { - return SerializableError.builder() - .putParameters("typeName", Objects.toString(parameters().typeName())) - .putParameters("typeDef", Objects.toString(parameters().typeDef())) - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()) - .build(); - } - } - - public static final class EndpointErrorException extends RemoteException { - private EndpointErrorSerializableError error; - - public EndpointErrorException(EndpointErrorSerializableError error, int status) { - super(error.toSerializableError(), status); - this.error = error; - } - - public EndpointErrorSerializableError error() { - return error; - } - } } diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EndpointSpecificTwoErrors.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EndpointSpecificTwoErrors.java index 210104a03..ff930dc05 100644 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EndpointSpecificTwoErrors.java +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/EndpointSpecificTwoErrors.java @@ -1,13 +1,8 @@ package undertow.com.palantir.product; -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.palantir.conjure.java.api.errors.AbstractSerializableError; import com.palantir.conjure.java.api.errors.ErrorType; import com.palantir.conjure.java.api.errors.RemoteException; -import com.palantir.conjure.java.api.errors.SerializableError; import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.Safe; import javax.annotation.processing.Generated; @Generated("com.palantir.conjure.java.types.ErrorGenerator") @@ -23,39 +18,4 @@ public static boolean isDifferentNamespace(RemoteException remoteException) { Preconditions.checkNotNull(remoteException, "remote exception must not be null"); return DIFFERENT_NAMESPACE.name().equals(remoteException.getError().errorName()); } - - public static record DifferentNamespaceParameters() {} - - public static final class DifferentNamespaceSerializableError - extends AbstractSerializableError { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - DifferentNamespaceSerializableError( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorName") @Safe String errorName, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") DifferentNamespaceParameters parameters) { - super(errorCode, errorName, errorInstanceId, parameters); - } - - public SerializableError toSerializableError() { - return SerializableError.builder() - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()) - .build(); - } - } - - public static final class DifferentNamespaceException extends RemoteException { - private DifferentNamespaceSerializableError error; - - public DifferentNamespaceException(DifferentNamespaceSerializableError error, int status) { - super(error.toSerializableError(), status); - this.error = error; - } - - public DifferentNamespaceSerializableError error() { - return error; - } - } } diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/TestErrors.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/TestErrors.java index d99b2a728..9f5db9eae 100644 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/TestErrors.java +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/TestErrors.java @@ -1,16 +1,8 @@ package undertow.com.palantir.product; -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.palantir.conjure.java.api.errors.AbstractSerializableError; import com.palantir.conjure.java.api.errors.ErrorType; import com.palantir.conjure.java.api.errors.RemoteException; -import com.palantir.conjure.java.api.errors.SerializableError; import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.Safe; -import com.palantir.logsafe.Unsafe; -import java.util.Map; -import java.util.Objects; import javax.annotation.processing.Generated; @Generated("com.palantir.conjure.java.types.ErrorGenerator") @@ -42,116 +34,4 @@ public static boolean isNotFound(RemoteException remoteException) { Preconditions.checkNotNull(remoteException, "remote exception must not be null"); return NOT_FOUND.name().equals(remoteException.getError().errorName()); } - - public static record ComplicatedParametersParameters( - @JsonProperty("complicatedObjectMap") @Safe Map complicatedObjectMap) {} - - public static record InvalidArgumentParameters( - @JsonProperty("field") @Safe String field, @JsonProperty("value") @Unsafe String value) {} - - public static record NotFoundParameters(@JsonProperty("resource") @Safe String resource) {} - - public static final class ComplicatedParametersSerializableError - extends AbstractSerializableError { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - ComplicatedParametersSerializableError( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorName") @Safe String errorName, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") ComplicatedParametersParameters parameters) { - super(errorCode, errorName, errorInstanceId, parameters); - } - - public SerializableError toSerializableError() { - return SerializableError.builder() - .putParameters( - "complicatedObjectMap", - Objects.toString(parameters().complicatedObjectMap())) - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()) - .build(); - } - } - - public static final class InvalidArgumentSerializableError - extends AbstractSerializableError { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - InvalidArgumentSerializableError( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorName") @Safe String errorName, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") InvalidArgumentParameters parameters) { - super(errorCode, errorName, errorInstanceId, parameters); - } - - public SerializableError toSerializableError() { - return SerializableError.builder() - .putParameters("field", Objects.toString(parameters().field())) - .putParameters("value", Objects.toString(parameters().value())) - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()) - .build(); - } - } - - public static final class NotFoundSerializableError extends AbstractSerializableError { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - NotFoundSerializableError( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorName") @Safe String errorName, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") NotFoundParameters parameters) { - super(errorCode, errorName, errorInstanceId, parameters); - } - - public SerializableError toSerializableError() { - return SerializableError.builder() - .putParameters("resource", Objects.toString(parameters().resource())) - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()) - .build(); - } - } - - public static final class ComplicatedParametersException extends RemoteException { - private ComplicatedParametersSerializableError error; - - public ComplicatedParametersException(ComplicatedParametersSerializableError error, int status) { - super(error.toSerializableError(), status); - this.error = error; - } - - public ComplicatedParametersSerializableError error() { - return error; - } - } - - public static final class InvalidArgumentException extends RemoteException { - private InvalidArgumentSerializableError error; - - public InvalidArgumentException(InvalidArgumentSerializableError error, int status) { - super(error.toSerializableError(), status); - this.error = error; - } - - public InvalidArgumentSerializableError error() { - return error; - } - } - - public static final class NotFoundException extends RemoteException { - private NotFoundSerializableError error; - - public NotFoundException(NotFoundSerializableError error, int status) { - super(error.toSerializableError(), status); - this.error = error; - } - - public NotFoundSerializableError error() { - return error; - } - } } diff --git a/conjure-java-core/src/main/java/com/palantir/conjure/java/services/dialogue/DefaultStaticFactoryMethodGenerator.java b/conjure-java-core/src/main/java/com/palantir/conjure/java/services/dialogue/DefaultStaticFactoryMethodGenerator.java index b7adc924b..4af1c6177 100644 --- a/conjure-java-core/src/main/java/com/palantir/conjure/java/services/dialogue/DefaultStaticFactoryMethodGenerator.java +++ b/conjure-java-core/src/main/java/com/palantir/conjure/java/services/dialogue/DefaultStaticFactoryMethodGenerator.java @@ -51,6 +51,7 @@ import com.palantir.dialogue.Deserializer; import com.palantir.dialogue.EndpointChannel; import com.palantir.dialogue.EndpointChannelFactory; +import com.palantir.dialogue.ExceptionDeserializerArgs; import com.palantir.dialogue.PlainSerDe; import com.palantir.dialogue.Request; import com.palantir.dialogue.Serializer; diff --git a/conjure-java-core/src/main/java/com/palantir/conjure/java/types/ErrorGenerator.java b/conjure-java-core/src/main/java/com/palantir/conjure/java/types/ErrorGenerator.java index 044234f0f..91ed757d8 100644 --- a/conjure-java-core/src/main/java/com/palantir/conjure/java/types/ErrorGenerator.java +++ b/conjure-java-core/src/main/java/com/palantir/conjure/java/types/ErrorGenerator.java @@ -30,7 +30,6 @@ import com.palantir.conjure.java.api.errors.ServiceException; import com.palantir.conjure.java.util.ErrorGenerationUtils; import com.palantir.conjure.java.util.ErrorGenerationUtils.DeclaredEndpointErrors; -import com.palantir.conjure.java.util.JavaNameSanitizer; import com.palantir.conjure.java.util.Packages; import com.palantir.conjure.java.util.TypeFunctions; import com.palantir.conjure.spec.ConjureDefinition; @@ -275,11 +274,7 @@ private static TypeSpec generateSerializableError(ErrorDefinition errorDefinitio for (int i = 0; i < allArgs.size(); i++) { FieldDefinition field = allArgs.get(i); String fieldName = field.getFieldName().get(); - builder.add( - ".putParameters($S, $T.toString(parameters().$L()))", - fieldName, - Objects.class, - JavaNameSanitizer.sanitizeErrorParameterName(fieldName)); + builder.add(".putParameters($S, $T.toString(parameters().$L()))", fieldName, Objects.class, fieldName); } builder.add(".errorCode(errorCode())") .add(".errorName(errorName())") diff --git a/conjure-java-core/src/main/java/com/palantir/conjure/java/util/ErrorGenerationUtils.java b/conjure-java-core/src/main/java/com/palantir/conjure/java/util/ErrorGenerationUtils.java index b6ab6a734..7cf0c4d87 100644 --- a/conjure-java-core/src/main/java/com/palantir/conjure/java/util/ErrorGenerationUtils.java +++ b/conjure-java-core/src/main/java/com/palantir/conjure/java/util/ErrorGenerationUtils.java @@ -70,7 +70,7 @@ public static String errorParametersClassName(String errorName) { public static ParameterSpec buildParameterWithSafetyAnnotationAndJsonProperty( TypeMapper typeMapper, FieldDefinition argDefinition, boolean isSafe) { ParameterSpec.Builder parameterBuilder = - buildParameterWithSafetyAnnotationInternal(typeMapper, argDefinition, isSafe); + buildParameterWithSafetyAnnotationInternal(typeMapper, argDefinition, isSafe, true); parameterBuilder.addAnnotation(AnnotationSpec.builder(JsonProperty.class) .addMember("value", "$S", argDefinition.getFieldName().get()) .build()); diff --git a/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowServiceEteTest.java b/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowServiceEteTest.java index 1b5752b7f..21f334d4f 100644 --- a/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowServiceEteTest.java +++ b/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowServiceEteTest.java @@ -589,7 +589,7 @@ public void testStringParametersDoNotChangeWhenUsingJsonAndJavaString() { // .getError() returns the SerializableError which should contain the legacy parameters sent over the wire. jsonParams = e.getError().parameters(); // e should be an instance of ErrorWithComplexArgsException, which has rich parameters as well. - assertThat(e).isInstanceOfSatisfying(ErrorWithComplexArgsException.class, exception -> { + assertThat(e.getCause()).isInstanceOfSatisfying(ErrorWithComplexArgsException.class, exception -> { assertThat(exception.error().parameters().optionalExample().getOptionalString()) .contains("optional-value"); }); diff --git a/versions.lock b/versions.lock index f7d3e4424..70fa02006 100644 --- a/versions.lock +++ b/versions.lock @@ -44,35 +44,35 @@ com.palantir.conjure:conjure-api-objects:4.50.0 (3 constraints: 9327531f) com.palantir.conjure:conjure-generator-common:4.50.0 (2 constraints: fd13a782) -com.palantir.conjure.java.api:errors:2.64.0 (8 constraints: a094bf79) +com.palantir.conjure.java.api:errors:2.64.0 (8 constraints: a394547a) -com.palantir.conjure.java.api:service-config:2.64.0 (6 constraints: 3466fcd7) +com.palantir.conjure.java.api:service-config:2.64.0 (6 constraints: 37668fd8) -com.palantir.conjure.java.api:ssl-config:2.64.0 (5 constraints: b44fa72d) +com.palantir.conjure.java.api:ssl-config:2.64.0 (5 constraints: b54faa2d) -com.palantir.conjure.java.runtime:client-config:8.24.0 (6 constraints: ab6bbb28) +com.palantir.conjure.java.runtime:client-config:8.24.0 (6 constraints: ae6b4e29) com.palantir.conjure.java.runtime:conjure-java-jackson-optimizations:8.24.0 (1 constraints: 841cc4a4) -com.palantir.conjure.java.runtime:conjure-java-jackson-serialization:8.24.0 (4 constraints: 2b4ac81e) +com.palantir.conjure.java.runtime:conjure-java-jackson-serialization:8.24.0 (4 constraints: 2c4acb1e) -com.palantir.conjure.java.runtime:keystores:8.24.0 (3 constraints: 162ac55d) +com.palantir.conjure.java.runtime:keystores:8.24.0 (3 constraints: 172ac85d) com.palantir.deadlines:deadlines:0.15.0 (2 constraints: 9f1404ac) -com.palantir.dialogue:dialogue-apache-hc5-client:6.7.0 (2 constraints: 1a2974b6) +com.palantir.dialogue:dialogue-apache-hc5-client:6.8.0-7-gde83dba (2 constraints: 6e2cef8c) -com.palantir.dialogue:dialogue-blocking-channels:6.7.0 (2 constraints: 79232973) +com.palantir.dialogue:dialogue-blocking-channels:6.8.0-7-gde83dba (2 constraints: 212a62b2) -com.palantir.dialogue:dialogue-clients:6.7.0 (1 constraints: 2908e185) +com.palantir.dialogue:dialogue-clients:6.8.0-7-gde83dba (1 constraints: 63080280) -com.palantir.dialogue:dialogue-core:6.7.0 (3 constraints: ea3c6541) +com.palantir.dialogue:dialogue-core:6.8.0-7-gde83dba (3 constraints: 924385ad) -com.palantir.dialogue:dialogue-futures:6.7.0 (3 constraints: 3e33a938) +com.palantir.dialogue:dialogue-futures:6.8.0-7-gde83dba (3 constraints: 3a3d7f36) -com.palantir.dialogue:dialogue-serde:6.7.0 (3 constraints: 423189e6) +com.palantir.dialogue:dialogue-serde:6.8.0-7-gde83dba (3 constraints: d034782d) -com.palantir.dialogue:dialogue-target:6.7.0 (7 constraints: eb7a1d92) +com.palantir.dialogue:dialogue-target:6.8.0-7-gde83dba (7 constraints: c98b0624) com.palantir.goethe:goethe:0.16.0 (1 constraints: 3905353b) @@ -124,7 +124,7 @@ com.squareup:javapoet:1.13.0 (1 constraints: f50b65f7) info.picocli:picocli:4.7.7 (1 constraints: 14051b36) -io.dropwizard.metrics:metrics-core:4.2.33 (28 constraints: f5e67410) +io.dropwizard.metrics:metrics-core:4.2.34 (28 constraints: f8e6781b) io.smallrye.common:smallrye-common-constraint:2.4.0 (3 constraints: c633ce60) @@ -182,7 +182,7 @@ org.jboss.xnio:xnio-api:3.8.16.Final (2 constraints: d71a2474) org.jboss.xnio:xnio-nio:3.8.16.Final (1 constraints: f80dc53d) -org.jetbrains:annotations:26.0.2 (4 constraints: 0a3aa099) +org.jetbrains:annotations:26.0.2 (5 constraints: df499f90) org.jspecify:jspecify:1.0.0 (17 constraints: b80bb9e1) diff --git a/versions.props b/versions.props index c67cedf94..93ea46cbf 100644 --- a/versions.props +++ b/versions.props @@ -12,7 +12,7 @@ com.palantir.conjure.verification:* = 0.19.0 com.palantir.conjure:* = 4.50.0 com.palantir.deadlines:* = 0.15.0 com.palantir.goethe:* = 0.16.0 -com.palantir.dialogue:* = 6.5.0-23-g3d8fa00 +com.palantir.dialogue:* = 6.8.0-7-gde83dba com.palantir.human-readable-types:* = 1.7.0 com.palantir.javapoet:javapoet = 0.7.0 com.palantir.ri:resource-identifier = 2.11.0 From bd0f97078be843493b62b75d4a4518ec1f13bce3 Mon Sep 17 00:00:00 2001 From: Pritham Marupaka Date: Tue, 26 Aug 2025 16:53:09 -0400 Subject: [PATCH 19/26] Undo test addition for easier review --- .../com/palantir/another/ConjureErrors.java | 40 --- .../com/palantir/product/ConjureErrors.java | 240 -------------- .../palantir/product/ConjureJavaErrors.java | 40 --- .../product/EmptyPathServiceAsync.java | 38 +-- .../product/EmptyPathServiceBlocking.java | 38 +-- .../product/EteBinaryServiceAsync.java | 119 ++----- .../product/EteBinaryServiceBlocking.java | 113 ++----- .../com/palantir/product/EteServiceAsync.java | 312 ++++-------------- .../palantir/product/EteServiceBlocking.java | 312 ++++-------------- .../dialogue/test/api/CookieServiceAsync.java | 17 +- .../test/api/CookieServiceBlocking.java | 17 +- .../conjure/java/UndertowServiceEteTest.java | 10 +- .../conjure/java/parameterized/TestCases.java | 5 +- 13 files changed, 176 insertions(+), 1125 deletions(-) diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/another/ConjureErrors.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/another/ConjureErrors.java index 541f49c2b..cdba5e331 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/another/ConjureErrors.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/another/ConjureErrors.java @@ -1,14 +1,9 @@ package dialogue.com.palantir.another; -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.palantir.conjure.java.api.errors.AbstractSerializableError; import com.palantir.conjure.java.api.errors.ErrorType; import com.palantir.conjure.java.api.errors.RemoteException; -import com.palantir.conjure.java.api.errors.SerializableError; import com.palantir.conjure.java.api.errors.ServiceException; import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.Safe; import javax.annotation.Nullable; import javax.annotation.processing.Generated; @@ -44,39 +39,4 @@ public static boolean isDifferentPackageError(RemoteException remoteException) { Preconditions.checkNotNull(remoteException, "remote exception must not be null"); return DIFFERENT_PACKAGE_ERROR.name().equals(remoteException.getError().errorName()); } - - public static record DifferentPackageErrorParameters() {} - - public static final class DifferentPackageErrorSerializableError - extends AbstractSerializableError { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - DifferentPackageErrorSerializableError( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorName") @Safe String errorName, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") DifferentPackageErrorParameters parameters) { - super(errorCode, errorName, errorInstanceId, parameters); - } - - public SerializableError toSerializableError() { - return SerializableError.builder() - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()) - .build(); - } - } - - public static final class DifferentPackageErrorException extends RemoteException { - private DifferentPackageErrorSerializableError error; - - public DifferentPackageErrorException(DifferentPackageErrorSerializableError error, int status) { - super(error.toSerializableError(), status); - this.error = error; - } - - public DifferentPackageErrorSerializableError error() { - return error; - } - } } diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureErrors.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureErrors.java index 89befeff1..b8ab5e6bf 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureErrors.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureErrors.java @@ -1,18 +1,13 @@ package dialogue.com.palantir.product; -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.palantir.conjure.java.api.errors.AbstractSerializableError; import com.palantir.conjure.java.api.errors.ErrorType; import com.palantir.conjure.java.api.errors.RemoteException; -import com.palantir.conjure.java.api.errors.SerializableError; import com.palantir.conjure.java.api.errors.ServiceException; import com.palantir.logsafe.Preconditions; import com.palantir.logsafe.Safe; import com.palantir.logsafe.SafeArg; import com.palantir.logsafe.Unsafe; import com.palantir.logsafe.UnsafeArg; -import java.util.Objects; import javax.annotation.Nullable; import javax.annotation.processing.Generated; @@ -329,239 +324,4 @@ public static boolean isInvalidTypeDefinition(RemoteException remoteException) { Preconditions.checkNotNull(remoteException, "remote exception must not be null"); return INVALID_TYPE_DEFINITION.name().equals(remoteException.getError().errorName()); } - - public static record ConflictingCauseSafeArgParameters( - @JsonProperty("cause") @Safe String cause, @JsonProperty("shouldThrow") @Safe boolean shouldThrow) {} - - public static record ConflictingCauseUnsafeArgParameters( - @JsonProperty("cause") @Unsafe String cause, @JsonProperty("shouldThrow") @Unsafe boolean shouldThrow) {} - - public static record ErrorWithComplexArgsParameters( - @JsonProperty("primitiveExample") @Safe PrimitiveExample primitiveExample, - @JsonProperty("collectionExample") @Safe CollectionExample collectionExample, - @JsonProperty("nestedCollectionExample") @Safe NestedCollectionExample nestedCollectionExample, - @JsonProperty("optionalExample") @Safe OptionalExample optionalExample, - @JsonProperty("objectReference") @Safe ObjectReference objectReference, - @JsonProperty("unionExample") @Safe UnionExample unionExample, - @JsonProperty("enumExample") @Safe EnumExample enumExample, - @JsonProperty("stringAlias") @Safe StringAliasEx stringAlias, - @JsonProperty("optionalAlias") @Safe OptionalAlias optionalAlias, - @JsonProperty("collectionAlias") @Safe CollectionAlias collectionAlias, - @JsonProperty("nestedAlias") @Safe NestedAlias nestedAlias, - @JsonProperty("externalExample") @Safe ExternalExample externalExample, - @JsonProperty("anyExample") @Safe AnyExample anyExample, - @JsonProperty("emptyObject") @Safe EmptyObject emptyObject, - @JsonProperty("complexExample") @Safe ComplexExample complexExample, - @JsonProperty("safetyExample") @Unsafe SafetyExample safetyExample) {} - - /** - * @param serviceName Name of the invalid service definition. - * @param serviceDef Details of the invalid service definition. - */ - public static record InvalidServiceDefinitionParameters( - @JsonProperty("serviceName") @Safe String serviceName, - @JsonProperty("serviceDef") @Unsafe Object serviceDef) {} - - public static record InvalidTypeDefinitionParameters( - @JsonProperty("typeName") @Safe String typeName, @JsonProperty("typeDef") @Unsafe Object typeDef) {} - - public static final class ConflictingCauseSafeArgSerializableError - extends AbstractSerializableError { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - ConflictingCauseSafeArgSerializableError( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorName") @Safe String errorName, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") ConflictingCauseSafeArgParameters parameters) { - super(errorCode, errorName, errorInstanceId, parameters); - } - - public SerializableError toSerializableError() { - return SerializableError.builder() - .putParameters("cause", Objects.toString(parameters().cause())) - .putParameters("shouldThrow", Objects.toString(parameters().shouldThrow())) - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()) - .build(); - } - } - - public static final class ConflictingCauseUnsafeArgSerializableError - extends AbstractSerializableError { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - ConflictingCauseUnsafeArgSerializableError( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorName") @Safe String errorName, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") ConflictingCauseUnsafeArgParameters parameters) { - super(errorCode, errorName, errorInstanceId, parameters); - } - - public SerializableError toSerializableError() { - return SerializableError.builder() - .putParameters("cause", Objects.toString(parameters().cause())) - .putParameters("shouldThrow", Objects.toString(parameters().shouldThrow())) - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()) - .build(); - } - } - - public static final class ErrorWithComplexArgsSerializableError - extends AbstractSerializableError { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - ErrorWithComplexArgsSerializableError( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorName") @Safe String errorName, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") ErrorWithComplexArgsParameters parameters) { - super(errorCode, errorName, errorInstanceId, parameters); - } - - public SerializableError toSerializableError() { - return SerializableError.builder() - .putParameters( - "primitiveExample", Objects.toString(parameters().primitiveExample())) - .putParameters( - "collectionExample", Objects.toString(parameters().collectionExample())) - .putParameters( - "nestedCollectionExample", - Objects.toString(parameters().nestedCollectionExample())) - .putParameters( - "optionalExample", Objects.toString(parameters().optionalExample())) - .putParameters( - "objectReference", Objects.toString(parameters().objectReference())) - .putParameters("unionExample", Objects.toString(parameters().unionExample())) - .putParameters("enumExample", Objects.toString(parameters().enumExample())) - .putParameters("stringAlias", Objects.toString(parameters().stringAlias())) - .putParameters( - "optionalAlias", Objects.toString(parameters().optionalAlias())) - .putParameters( - "collectionAlias", Objects.toString(parameters().collectionAlias())) - .putParameters("nestedAlias", Objects.toString(parameters().nestedAlias())) - .putParameters( - "externalExample", Objects.toString(parameters().externalExample())) - .putParameters("anyExample", Objects.toString(parameters().anyExample())) - .putParameters("emptyObject", Objects.toString(parameters().emptyObject())) - .putParameters( - "complexExample", Objects.toString(parameters().complexExample())) - .putParameters( - "safetyExample", Objects.toString(parameters().safetyExample())) - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()) - .build(); - } - } - - public static final class InvalidServiceDefinitionSerializableError - extends AbstractSerializableError { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - InvalidServiceDefinitionSerializableError( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorName") @Safe String errorName, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") InvalidServiceDefinitionParameters parameters) { - super(errorCode, errorName, errorInstanceId, parameters); - } - - public SerializableError toSerializableError() { - return SerializableError.builder() - .putParameters("serviceName", Objects.toString(parameters().serviceName())) - .putParameters("serviceDef", Objects.toString(parameters().serviceDef())) - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()) - .build(); - } - } - - public static final class InvalidTypeDefinitionSerializableError - extends AbstractSerializableError { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - InvalidTypeDefinitionSerializableError( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorName") @Safe String errorName, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") InvalidTypeDefinitionParameters parameters) { - super(errorCode, errorName, errorInstanceId, parameters); - } - - public SerializableError toSerializableError() { - return SerializableError.builder() - .putParameters("typeName", Objects.toString(parameters().typeName())) - .putParameters("typeDef", Objects.toString(parameters().typeDef())) - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()) - .build(); - } - } - - public static final class ConflictingCauseSafeArgException extends RemoteException { - private ConflictingCauseSafeArgSerializableError error; - - public ConflictingCauseSafeArgException(ConflictingCauseSafeArgSerializableError error, int status) { - super(error.toSerializableError(), status); - this.error = error; - } - - public ConflictingCauseSafeArgSerializableError error() { - return error; - } - } - - public static final class ConflictingCauseUnsafeArgException extends RemoteException { - private ConflictingCauseUnsafeArgSerializableError error; - - public ConflictingCauseUnsafeArgException(ConflictingCauseUnsafeArgSerializableError error, int status) { - super(error.toSerializableError(), status); - this.error = error; - } - - public ConflictingCauseUnsafeArgSerializableError error() { - return error; - } - } - - public static final class ErrorWithComplexArgsException extends RemoteException { - private ErrorWithComplexArgsSerializableError error; - - public ErrorWithComplexArgsException(ErrorWithComplexArgsSerializableError error, int status) { - super(error.toSerializableError(), status); - this.error = error; - } - - public ErrorWithComplexArgsSerializableError error() { - return error; - } - } - - public static final class InvalidServiceDefinitionException extends RemoteException { - private InvalidServiceDefinitionSerializableError error; - - public InvalidServiceDefinitionException(InvalidServiceDefinitionSerializableError error, int status) { - super(error.toSerializableError(), status); - this.error = error; - } - - public InvalidServiceDefinitionSerializableError error() { - return error; - } - } - - public static final class InvalidTypeDefinitionException extends RemoteException { - private InvalidTypeDefinitionSerializableError error; - - public InvalidTypeDefinitionException(InvalidTypeDefinitionSerializableError error, int status) { - super(error.toSerializableError(), status); - this.error = error; - } - - public InvalidTypeDefinitionSerializableError error() { - return error; - } - } } diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureJavaErrors.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureJavaErrors.java index ff44ed2c9..def54f2f8 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureJavaErrors.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureJavaErrors.java @@ -1,14 +1,9 @@ package dialogue.com.palantir.product; -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.palantir.conjure.java.api.errors.AbstractSerializableError; import com.palantir.conjure.java.api.errors.ErrorType; import com.palantir.conjure.java.api.errors.RemoteException; -import com.palantir.conjure.java.api.errors.SerializableError; import com.palantir.conjure.java.api.errors.ServiceException; import com.palantir.logsafe.Preconditions; -import com.palantir.logsafe.Safe; import javax.annotation.Nullable; import javax.annotation.processing.Generated; @@ -44,39 +39,4 @@ public static boolean isJavaCompilationFailed(RemoteException remoteException) { Preconditions.checkNotNull(remoteException, "remote exception must not be null"); return JAVA_COMPILATION_FAILED.name().equals(remoteException.getError().errorName()); } - - public static record JavaCompilationFailedParameters() {} - - public static final class JavaCompilationFailedSerializableError - extends AbstractSerializableError { - @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) - JavaCompilationFailedSerializableError( - @JsonProperty("errorCode") @Safe String errorCode, - @JsonProperty("errorName") @Safe String errorName, - @JsonProperty("errorInstanceId") @Safe String errorInstanceId, - @JsonProperty("parameters") JavaCompilationFailedParameters parameters) { - super(errorCode, errorName, errorInstanceId, parameters); - } - - public SerializableError toSerializableError() { - return SerializableError.builder() - .errorCode(errorCode()) - .errorName(errorName()) - .errorInstanceId(errorInstanceId()) - .build(); - } - } - - public static final class JavaCompilationFailedException extends RemoteException { - private JavaCompilationFailedSerializableError error; - - public JavaCompilationFailedException(JavaCompilationFailedSerializableError error, int status) { - super(error.toSerializableError(), status); - this.error = error; - } - - public JavaCompilationFailedSerializableError error() { - return error; - } - } } diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceAsync.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceAsync.java index 463bc4d1c..1cb0a894e 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceAsync.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceAsync.java @@ -10,7 +10,6 @@ import com.palantir.dialogue.Endpoint; import com.palantir.dialogue.EndpointChannel; import com.palantir.dialogue.EndpointChannelFactory; -import com.palantir.dialogue.ExceptionDeserializerArgs; import com.palantir.dialogue.PlainSerDe; import com.palantir.dialogue.Request; import com.palantir.dialogue.TypeMarker; @@ -35,46 +34,11 @@ static EmptyPathServiceAsync of(EndpointChannelFactory _endpointChannelFactory, _endpointChannelFactory.endpoint(DialogueEmptyPathEndpoints.emptyPath); private final Deserializer emptyPathDeserializer = - _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); - - private ExceptionDeserializerArgs createExceptionDeserializerArgs(TypeMarker returnType) { - return ExceptionDeserializerArgs.builder() - .returnType(returnType) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build(); - } + _runtime.bodySerDe().deserializer(new TypeMarker() {}); @Override public ListenableFuture emptyPath() { Request.Builder _request = Request.builder(); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients().call(emptyPathChannel, _request.build(), emptyPathDeserializer); } diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceBlocking.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceBlocking.java index ae1deb4bc..38a0f3426 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceBlocking.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceBlocking.java @@ -9,7 +9,6 @@ import com.palantir.dialogue.Endpoint; import com.palantir.dialogue.EndpointChannel; import com.palantir.dialogue.EndpointChannelFactory; -import com.palantir.dialogue.ExceptionDeserializerArgs; import com.palantir.dialogue.PlainSerDe; import com.palantir.dialogue.Request; import com.palantir.dialogue.TypeMarker; @@ -34,46 +33,11 @@ static EmptyPathServiceBlocking of(EndpointChannelFactory _endpointChannelFactor _endpointChannelFactory.endpoint(DialogueEmptyPathEndpoints.emptyPath); private final Deserializer emptyPathDeserializer = - _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); - - private ExceptionDeserializerArgs createExceptionDeserializerArgs(TypeMarker returnType) { - return ExceptionDeserializerArgs.builder() - .returnType(returnType) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build(); - } + _runtime.bodySerDe().deserializer(new TypeMarker() {}); @Override public boolean emptyPath() { Request.Builder _request = Request.builder(); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients().callBlocking(emptyPathChannel, _request.build(), emptyPathDeserializer); } diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceAsync.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceAsync.java index 42823d245..0475a8808 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceAsync.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceAsync.java @@ -5,16 +5,13 @@ import com.palantir.dialogue.BinaryRequestBody; import com.palantir.dialogue.Channel; import com.palantir.dialogue.ConjureRuntime; -import com.palantir.dialogue.Deserializer; import com.palantir.dialogue.DialogueService; import com.palantir.dialogue.DialogueServiceFactory; import com.palantir.dialogue.Endpoint; import com.palantir.dialogue.EndpointChannel; import com.palantir.dialogue.EndpointChannelFactory; -import com.palantir.dialogue.ExceptionDeserializerArgs; import com.palantir.dialogue.PlainSerDe; import com.palantir.dialogue.Request; -import com.palantir.dialogue.TypeMarker; import com.palantir.tokens.auth.AuthHeader; import java.io.InputStream; import java.lang.Override; @@ -61,84 +58,31 @@ static EteBinaryServiceAsync of(EndpointChannelFactory _endpointChannelFactory, private final EndpointChannel postBinaryChannel = _endpointChannelFactory.endpoint(DialogueEteBinaryEndpoints.postBinary); - private final Deserializer postBinaryDeserializer = _runtime.bodySerDe() - .inputStreamDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); - private final EndpointChannel postBinaryThrowsChannel = _endpointChannelFactory.endpoint(DialogueEteBinaryEndpoints.postBinaryThrows); - private final Deserializer postBinaryThrowsDeserializer = _runtime.bodySerDe() - .inputStreamDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); - private final EndpointChannel getOptionalBinaryPresentChannel = _endpointChannelFactory.endpoint(DialogueEteBinaryEndpoints.getOptionalBinaryPresent); - private final Deserializer> getOptionalBinaryPresentDeserializer = - _runtime.bodySerDe() - .optionalInputStreamDeserializer( - createExceptionDeserializerArgs(new TypeMarker>() {})); - private final EndpointChannel getOptionalBinaryEmptyChannel = _endpointChannelFactory.endpoint(DialogueEteBinaryEndpoints.getOptionalBinaryEmpty); - private final Deserializer> getOptionalBinaryEmptyDeserializer = _runtime.bodySerDe() - .optionalInputStreamDeserializer( - createExceptionDeserializerArgs(new TypeMarker>() {})); - private final EndpointChannel getBinaryFailureChannel = _endpointChannelFactory.endpoint(DialogueEteBinaryEndpoints.getBinaryFailure); - private final Deserializer getBinaryFailureDeserializer = _runtime.bodySerDe() - .inputStreamDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); - private final EndpointChannel getAliasedChannel = _endpointChannelFactory.endpoint(DialogueEteBinaryEndpoints.getAliased); - private final Deserializer> getAliasedDeserializer = _runtime.bodySerDe() - .optionalInputStreamDeserializer( - createExceptionDeserializerArgs(new TypeMarker>() {})); - - private ExceptionDeserializerArgs createExceptionDeserializerArgs(TypeMarker returnType) { - return ExceptionDeserializerArgs.builder() - .returnType(returnType) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build(); - } - @Override public ListenableFuture postBinary(AuthHeader authHeader, BinaryRequestBody body) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(_runtime.bodySerDe().serialize(body)); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } - return _runtime.clients().call(postBinaryChannel, _request.build(), postBinaryDeserializer); + return _runtime.clients() + .call( + postBinaryChannel, + _request.build(), + _runtime.bodySerDe().inputStreamDeserializer()); } @Override @@ -148,38 +92,33 @@ public ListenableFuture postBinaryThrows( _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(_runtime.bodySerDe().serialize(body)); _request.putQueryParams("bytesToRead", _plainSerDe.serializeInteger(bytesToRead)); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } - return _runtime.clients().call(postBinaryThrowsChannel, _request.build(), postBinaryThrowsDeserializer); + return _runtime.clients() + .call( + postBinaryThrowsChannel, + _request.build(), + _runtime.bodySerDe().inputStreamDeserializer()); } @Override public ListenableFuture> getOptionalBinaryPresent(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients() - .call(getOptionalBinaryPresentChannel, _request.build(), getOptionalBinaryPresentDeserializer); + .call( + getOptionalBinaryPresentChannel, + _request.build(), + _runtime.bodySerDe().optionalInputStreamDeserializer()); } @Override public ListenableFuture> getOptionalBinaryEmpty(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients() - .call(getOptionalBinaryEmptyChannel, _request.build(), getOptionalBinaryEmptyDeserializer); + .call( + getOptionalBinaryEmptyChannel, + _request.build(), + _runtime.bodySerDe().optionalInputStreamDeserializer()); } @Override @@ -189,24 +128,22 @@ public ListenableFuture getBinaryFailure( _request.putHeaderParams("Authorization", authHeader.toString()); _request.putQueryParams("numBytes", _plainSerDe.serializeInteger(numBytes)); _request.putQueryParams("useTryWithResources", _plainSerDe.serializeBoolean(useTryWithResources)); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } - return _runtime.clients().call(getBinaryFailureChannel, _request.build(), getBinaryFailureDeserializer); + return _runtime.clients() + .call( + getBinaryFailureChannel, + _request.build(), + _runtime.bodySerDe().inputStreamDeserializer()); } @Override public ListenableFuture> getAliased(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } - return _runtime.clients().call(getAliasedChannel, _request.build(), getAliasedDeserializer); + return _runtime.clients() + .call( + getAliasedChannel, + _request.build(), + _runtime.bodySerDe().optionalInputStreamDeserializer()); } @Override diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceBlocking.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceBlocking.java index 7ca026b1b..57533e186 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceBlocking.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceBlocking.java @@ -5,16 +5,13 @@ import com.palantir.dialogue.BinaryRequestBody; import com.palantir.dialogue.Channel; import com.palantir.dialogue.ConjureRuntime; -import com.palantir.dialogue.Deserializer; import com.palantir.dialogue.DialogueService; import com.palantir.dialogue.DialogueServiceFactory; import com.palantir.dialogue.Endpoint; import com.palantir.dialogue.EndpointChannel; import com.palantir.dialogue.EndpointChannelFactory; -import com.palantir.dialogue.ExceptionDeserializerArgs; import com.palantir.dialogue.PlainSerDe; import com.palantir.dialogue.Request; -import com.palantir.dialogue.TypeMarker; import com.palantir.tokens.auth.AuthHeader; import java.io.InputStream; import java.lang.Override; @@ -64,84 +61,31 @@ static EteBinaryServiceBlocking of(EndpointChannelFactory _endpointChannelFactor private final EndpointChannel postBinaryChannel = _endpointChannelFactory.endpoint(DialogueEteBinaryEndpoints.postBinary); - private final Deserializer postBinaryDeserializer = _runtime.bodySerDe() - .inputStreamDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); - private final EndpointChannel postBinaryThrowsChannel = _endpointChannelFactory.endpoint(DialogueEteBinaryEndpoints.postBinaryThrows); - private final Deserializer postBinaryThrowsDeserializer = _runtime.bodySerDe() - .inputStreamDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); - private final EndpointChannel getOptionalBinaryPresentChannel = _endpointChannelFactory.endpoint(DialogueEteBinaryEndpoints.getOptionalBinaryPresent); - private final Deserializer> getOptionalBinaryPresentDeserializer = - _runtime.bodySerDe() - .optionalInputStreamDeserializer( - createExceptionDeserializerArgs(new TypeMarker>() {})); - private final EndpointChannel getOptionalBinaryEmptyChannel = _endpointChannelFactory.endpoint(DialogueEteBinaryEndpoints.getOptionalBinaryEmpty); - private final Deserializer> getOptionalBinaryEmptyDeserializer = _runtime.bodySerDe() - .optionalInputStreamDeserializer( - createExceptionDeserializerArgs(new TypeMarker>() {})); - private final EndpointChannel getBinaryFailureChannel = _endpointChannelFactory.endpoint(DialogueEteBinaryEndpoints.getBinaryFailure); - private final Deserializer getBinaryFailureDeserializer = _runtime.bodySerDe() - .inputStreamDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); - private final EndpointChannel getAliasedChannel = _endpointChannelFactory.endpoint(DialogueEteBinaryEndpoints.getAliased); - private final Deserializer> getAliasedDeserializer = _runtime.bodySerDe() - .optionalInputStreamDeserializer( - createExceptionDeserializerArgs(new TypeMarker>() {})); - - private ExceptionDeserializerArgs createExceptionDeserializerArgs(TypeMarker returnType) { - return ExceptionDeserializerArgs.builder() - .returnType(returnType) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build(); - } - @Override public InputStream postBinary(AuthHeader authHeader, BinaryRequestBody body) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(_runtime.bodySerDe().serialize(body)); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } - return _runtime.clients().callBlocking(postBinaryChannel, _request.build(), postBinaryDeserializer); + return _runtime.clients() + .callBlocking( + postBinaryChannel, + _request.build(), + _runtime.bodySerDe().inputStreamDeserializer()); } @Override @@ -150,43 +94,33 @@ public InputStream postBinaryThrows(AuthHeader authHeader, int bytesToRead, Bina _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(_runtime.bodySerDe().serialize(body)); _request.putQueryParams("bytesToRead", _plainSerDe.serializeInteger(bytesToRead)); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients() - .callBlocking(postBinaryThrowsChannel, _request.build(), postBinaryThrowsDeserializer); + .callBlocking( + postBinaryThrowsChannel, + _request.build(), + _runtime.bodySerDe().inputStreamDeserializer()); } @Override public Optional getOptionalBinaryPresent(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients() .callBlocking( getOptionalBinaryPresentChannel, _request.build(), - getOptionalBinaryPresentDeserializer); + _runtime.bodySerDe().optionalInputStreamDeserializer()); } @Override public Optional getOptionalBinaryEmpty(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients() .callBlocking( - getOptionalBinaryEmptyChannel, _request.build(), getOptionalBinaryEmptyDeserializer); + getOptionalBinaryEmptyChannel, + _request.build(), + _runtime.bodySerDe().optionalInputStreamDeserializer()); } @Override @@ -195,25 +129,22 @@ public InputStream getBinaryFailure(AuthHeader authHeader, int numBytes, boolean _request.putHeaderParams("Authorization", authHeader.toString()); _request.putQueryParams("numBytes", _plainSerDe.serializeInteger(numBytes)); _request.putQueryParams("useTryWithResources", _plainSerDe.serializeBoolean(useTryWithResources)); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients() - .callBlocking(getBinaryFailureChannel, _request.build(), getBinaryFailureDeserializer); + .callBlocking( + getBinaryFailureChannel, + _request.build(), + _runtime.bodySerDe().inputStreamDeserializer()); } @Override public Optional getAliased(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } - return _runtime.clients().callBlocking(getAliasedChannel, _request.build(), getAliasedDeserializer); + return _runtime.clients() + .callBlocking( + getAliasedChannel, + _request.build(), + _runtime.bodySerDe().optionalInputStreamDeserializer()); } @Override diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceAsync.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceAsync.java index b60d0e56c..e4f65beff 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceAsync.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceAsync.java @@ -11,7 +11,6 @@ import com.palantir.dialogue.Endpoint; import com.palantir.dialogue.EndpointChannel; import com.palantir.dialogue.EndpointChannelFactory; -import com.palantir.dialogue.ExceptionDeserializerArgs; import com.palantir.dialogue.PlainSerDe; import com.palantir.dialogue.Request; import com.palantir.dialogue.Serializer; @@ -220,82 +219,79 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur private final EndpointChannel stringChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.string); private final Deserializer stringDeserializer = - _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + _runtime.bodySerDe().deserializer(new TypeMarker() {}); private final EndpointChannel integerChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.integer); private final Deserializer integerDeserializer = - _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + _runtime.bodySerDe().deserializer(new TypeMarker() {}); private final EndpointChannel double_Channel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.double_); private final Deserializer double_Deserializer = - _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + _runtime.bodySerDe().deserializer(new TypeMarker() {}); private final EndpointChannel boolean_Channel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.boolean_); private final Deserializer boolean_Deserializer = - _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + _runtime.bodySerDe().deserializer(new TypeMarker() {}); private final EndpointChannel safelongChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.safelong); private final Deserializer safelongDeserializer = - _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + _runtime.bodySerDe().deserializer(new TypeMarker() {}); private final EndpointChannel ridChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.rid); - private final Deserializer ridDeserializer = _runtime.bodySerDe() - .deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final Deserializer ridDeserializer = + _runtime.bodySerDe().deserializer(new TypeMarker() {}); private final EndpointChannel bearertokenChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.bearertoken); - private final Deserializer bearertokenDeserializer = _runtime.bodySerDe() - .deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final Deserializer bearertokenDeserializer = + _runtime.bodySerDe().deserializer(new TypeMarker() {}); private final EndpointChannel optionalStringChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalString); - private final Deserializer> optionalStringDeserializer = _runtime.bodySerDe() - .deserializer(createExceptionDeserializerArgs(new TypeMarker>() {})); + private final Deserializer> optionalStringDeserializer = + _runtime.bodySerDe().deserializer(new TypeMarker>() {}); private final EndpointChannel optionalEmptyChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalEmpty); - private final Deserializer> optionalEmptyDeserializer = _runtime.bodySerDe() - .deserializer(createExceptionDeserializerArgs(new TypeMarker>() {})); + private final Deserializer> optionalEmptyDeserializer = + _runtime.bodySerDe().deserializer(new TypeMarker>() {}); private final EndpointChannel datetimeChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.datetime); - private final Deserializer datetimeDeserializer = _runtime.bodySerDe() - .deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final Deserializer datetimeDeserializer = + _runtime.bodySerDe().deserializer(new TypeMarker() {}); private final EndpointChannel binaryChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.binary); - private final Deserializer binaryDeserializer = _runtime.bodySerDe() - .inputStreamDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); - private final EndpointChannel pathChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.path); private final Deserializer pathDeserializer = - _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + _runtime.bodySerDe().deserializer(new TypeMarker() {}); private final EndpointChannel externalLongPathChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.externalLongPath); private final Deserializer externalLongPathDeserializer = - _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + _runtime.bodySerDe().deserializer(new TypeMarker() {}); private final EndpointChannel optionalExternalLongQueryChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalExternalLongQuery); - private final Deserializer> optionalExternalLongQueryDeserializer = _runtime.bodySerDe() - .deserializer(createExceptionDeserializerArgs(new TypeMarker>() {})); + private final Deserializer> optionalExternalLongQueryDeserializer = + _runtime.bodySerDe().deserializer(new TypeMarker>() {}); private final Serializer notNullBodySerializer = _runtime.bodySerDe().serializer(new TypeMarker() {}); @@ -303,26 +299,26 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur private final EndpointChannel notNullBodyChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.notNullBody); - private final Deserializer notNullBodyDeserializer = _runtime.bodySerDe() - .deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final Deserializer notNullBodyDeserializer = + _runtime.bodySerDe().deserializer(new TypeMarker() {}); private final EndpointChannel aliasOneChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.aliasOne); - private final Deserializer aliasOneDeserializer = _runtime.bodySerDe() - .deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final Deserializer aliasOneDeserializer = + _runtime.bodySerDe().deserializer(new TypeMarker() {}); private final EndpointChannel optionalAliasOneChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalAliasOne); - private final Deserializer optionalAliasOneDeserializer = _runtime.bodySerDe() - .deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final Deserializer optionalAliasOneDeserializer = + _runtime.bodySerDe().deserializer(new TypeMarker() {}); private final EndpointChannel aliasTwoChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.aliasTwo); - private final Deserializer aliasTwoDeserializer = _runtime.bodySerDe() - .deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final Deserializer aliasTwoDeserializer = + _runtime.bodySerDe().deserializer(new TypeMarker() {}); private final Serializer notNullBodyExternalImportSerializer = _runtime.bodySerDe() @@ -333,8 +329,7 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur private final Deserializer notNullBodyExternalImportDeserializer = _runtime.bodySerDe() - .deserializer(createExceptionDeserializerArgs( - new TypeMarker() {})); + .deserializer(new TypeMarker() {}); private final Serializer> optionalBodyExternalImportSerializer = _runtime.bodySerDe() @@ -346,72 +341,70 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur private final Deserializer> optionalBodyExternalImportDeserializer = _runtime.bodySerDe() - .deserializer(createExceptionDeserializerArgs( - new TypeMarker< - Optional>() {})); + .deserializer( + new TypeMarker>() {}); private final EndpointChannel optionalQueryExternalImportChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalQueryExternalImport); private final Deserializer> optionalQueryExternalImportDeserializer = _runtime.bodySerDe() - .deserializer(createExceptionDeserializerArgs( - new TypeMarker< - Optional>() {})); + .deserializer( + new TypeMarker>() {}); private final EndpointChannel noReturnChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.noReturn); - private final Deserializer noReturnDeserializer = _runtime.bodySerDe() - .emptyBodyDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final Deserializer noReturnDeserializer = + _runtime.bodySerDe().emptyBodyDeserializer(); private final EndpointChannel enumQueryChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.enumQuery); private final Deserializer enumQueryDeserializer = - _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + _runtime.bodySerDe().deserializer(new TypeMarker() {}); private final EndpointChannel enumListQueryChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.enumListQuery); - private final Deserializer> enumListQueryDeserializer = _runtime.bodySerDe() - .deserializer(createExceptionDeserializerArgs(new TypeMarker>() {})); + private final Deserializer> enumListQueryDeserializer = + _runtime.bodySerDe().deserializer(new TypeMarker>() {}); private final EndpointChannel optionalEnumQueryChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalEnumQuery); - private final Deserializer> optionalEnumQueryDeserializer = _runtime.bodySerDe() - .deserializer(createExceptionDeserializerArgs(new TypeMarker>() {})); + private final Deserializer> optionalEnumQueryDeserializer = + _runtime.bodySerDe().deserializer(new TypeMarker>() {}); private final EndpointChannel enumHeaderChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.enumHeader); private final Deserializer enumHeaderDeserializer = - _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + _runtime.bodySerDe().deserializer(new TypeMarker() {}); private final EndpointChannel jsonErrorsHeaderChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.jsonErrorsHeader); private final Deserializer jsonErrorsHeaderDeserializer = - _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + _runtime.bodySerDe().deserializer(new TypeMarker() {}); private final EndpointChannel errorParameterSerializationChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.errorParameterSerialization); private final Deserializer errorParameterSerializationDeserializer = - _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + _runtime.bodySerDe().deserializer(new TypeMarker() {}); private final EndpointChannel aliasLongEndpointChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.aliasLongEndpoint); - private final Deserializer> aliasLongEndpointDeserializer = _runtime.bodySerDe() - .deserializer(createExceptionDeserializerArgs(new TypeMarker>() {})); + private final Deserializer> aliasLongEndpointDeserializer = + _runtime.bodySerDe().deserializer(new TypeMarker>() {}); private final EndpointChannel complexQueryParametersChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.complexQueryParameters); - private final Deserializer complexQueryParametersDeserializer = _runtime.bodySerDe() - .emptyBodyDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final Deserializer complexQueryParametersDeserializer = + _runtime.bodySerDe().emptyBodyDeserializer(); private final Serializer>> receiveListOfOptionalsSerializer = _runtime.bodySerDe().serializer(new TypeMarker>>() {}); @@ -419,8 +412,8 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur private final EndpointChannel receiveListOfOptionalsChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.receiveListOfOptionals); - private final Deserializer receiveListOfOptionalsDeserializer = _runtime.bodySerDe() - .emptyBodyDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final Deserializer receiveListOfOptionalsDeserializer = + _runtime.bodySerDe().emptyBodyDeserializer(); private final Serializer>> receiveSetOfOptionalsSerializer = _runtime.bodySerDe().serializer(new TypeMarker>>() {}); @@ -428,8 +421,8 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur private final EndpointChannel receiveSetOfOptionalsChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.receiveSetOfOptionals); - private final Deserializer receiveSetOfOptionalsDeserializer = _runtime.bodySerDe() - .emptyBodyDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final Deserializer receiveSetOfOptionalsDeserializer = + _runtime.bodySerDe().emptyBodyDeserializer(); private final Serializer> receiveListOfStringsSerializer = _runtime.bodySerDe().serializer(new TypeMarker>() {}); @@ -437,48 +430,13 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur private final EndpointChannel receiveListOfStringsChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.receiveListOfStrings); - private final Deserializer receiveListOfStringsDeserializer = _runtime.bodySerDe() - .emptyBodyDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); - - private ExceptionDeserializerArgs createExceptionDeserializerArgs(TypeMarker returnType) { - return ExceptionDeserializerArgs.builder() - .returnType(returnType) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build(); - } + private final Deserializer receiveListOfStringsDeserializer = + _runtime.bodySerDe().emptyBodyDeserializer(); @Override public ListenableFuture string(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients().call(stringChannel, _request.build(), stringDeserializer); } @@ -486,11 +444,6 @@ public ListenableFuture string(AuthHeader authHeader) { public ListenableFuture integer(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients().call(integerChannel, _request.build(), integerDeserializer); } @@ -498,11 +451,6 @@ public ListenableFuture integer(AuthHeader authHeader) { public ListenableFuture double_(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients().call(double_Channel, _request.build(), double_Deserializer); } @@ -510,11 +458,6 @@ public ListenableFuture double_(AuthHeader authHeader) { public ListenableFuture boolean_(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients().call(boolean_Channel, _request.build(), boolean_Deserializer); } @@ -522,11 +465,6 @@ public ListenableFuture boolean_(AuthHeader authHeader) { public ListenableFuture safelong(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients().call(safelongChannel, _request.build(), safelongDeserializer); } @@ -534,11 +472,6 @@ public ListenableFuture safelong(AuthHeader authHeader) { public ListenableFuture rid(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients().call(ridChannel, _request.build(), ridDeserializer); } @@ -546,11 +479,6 @@ public ListenableFuture rid(AuthHeader authHeader) { public ListenableFuture bearertoken(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients().call(bearertokenChannel, _request.build(), bearertokenDeserializer); } @@ -558,11 +486,6 @@ public ListenableFuture bearertoken(AuthHeader authHeader) { public ListenableFuture> optionalString(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients().call(optionalStringChannel, _request.build(), optionalStringDeserializer); } @@ -570,11 +493,6 @@ public ListenableFuture> optionalString(AuthHeader authHeader) public ListenableFuture> optionalEmpty(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients().call(optionalEmptyChannel, _request.build(), optionalEmptyDeserializer); } @@ -582,11 +500,6 @@ public ListenableFuture> optionalEmpty(AuthHeader authHeader) { public ListenableFuture datetime(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients().call(datetimeChannel, _request.build(), datetimeDeserializer); } @@ -594,12 +507,11 @@ public ListenableFuture datetime(AuthHeader authHeader) { public ListenableFuture binary(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } - return _runtime.clients().call(binaryChannel, _request.build(), binaryDeserializer); + return _runtime.clients() + .call( + binaryChannel, + _request.build(), + _runtime.bodySerDe().inputStreamDeserializer()); } @Override @@ -607,11 +519,6 @@ public ListenableFuture path(AuthHeader authHeader, String param) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("param", _plainSerDe.serializeString(param)); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients().call(pathChannel, _request.build(), pathDeserializer); } @@ -620,11 +527,6 @@ public ListenableFuture externalLongPath(AuthHeader authHeader, long param Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("param", Objects.toString(param)); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients().call(externalLongPathChannel, _request.build(), externalLongPathDeserializer); } @@ -636,11 +538,6 @@ public ListenableFuture> optionalExternalLongQuery( if (param.isPresent()) { _request.putQueryParams("param", Objects.toString(param.get())); } - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients() .call( optionalExternalLongQueryChannel, @@ -654,11 +551,6 @@ public ListenableFuture notNullBody( Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(notNullBodySerializer.serialize(notNullBody)); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients().call(notNullBodyChannel, _request.build(), notNullBodyDeserializer); } @@ -668,11 +560,6 @@ public ListenableFuture aliasOne( Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putQueryParams("queryParamName", _plainSerDe.serializeString(queryParamName.get())); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients().call(aliasOneChannel, _request.build(), aliasOneDeserializer); } @@ -686,11 +573,6 @@ public ListenableFuture optionalAliasOne( "queryParamName", _plainSerDe.serializeString(queryParamName.get().get())); } - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients().call(optionalAliasOneChannel, _request.build(), optionalAliasOneDeserializer); } @@ -702,11 +584,6 @@ public ListenableFuture aliasTwo( _request.putQueryParams( "queryParamName", _plainSerDe.serializeString(queryParamName.get().get())); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients().call(aliasTwoChannel, _request.build(), aliasTwoDeserializer); } @@ -716,11 +593,6 @@ public ListenableFuture not Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(notNullBodyExternalImportSerializer.serialize(notNullBody)); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients() .call( notNullBodyExternalImportChannel, @@ -735,11 +607,6 @@ public ListenableFuture not Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(optionalBodyExternalImportSerializer.serialize(body)); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients() .call( optionalBodyExternalImportChannel, @@ -757,11 +624,6 @@ public ListenableFuture not if (query.isPresent()) { _request.putQueryParams("query", Objects.toString(query.get())); } - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients() .call( optionalQueryExternalImportChannel, @@ -773,11 +635,6 @@ public ListenableFuture not public ListenableFuture noReturn(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients().call(noReturnChannel, _request.build(), noReturnDeserializer); } @@ -786,11 +643,6 @@ public ListenableFuture enumQuery(AuthHeader authHeader, SimpleEnum Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putQueryParams("queryParamName", Objects.toString(queryParamName)); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients().call(enumQueryChannel, _request.build(), enumQueryDeserializer); } @@ -802,11 +654,6 @@ public ListenableFuture> enumListQuery( for (SimpleEnum queryParamNameElement : queryParamName) { _request.putQueryParams("queryParamName", Objects.toString(queryParamNameElement)); } - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients().call(enumListQueryChannel, _request.build(), enumListQueryDeserializer); } @@ -818,11 +665,6 @@ public ListenableFuture> optionalEnumQuery( if (queryParamName.isPresent()) { _request.putQueryParams("queryParamName", Objects.toString(queryParamName.get())); } - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients() .call(optionalEnumQueryChannel, _request.build(), optionalEnumQueryDeserializer); } @@ -832,11 +674,6 @@ public ListenableFuture enumHeader(AuthHeader authHeader, SimpleEnum Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putHeaderParams("Custom-Header", Objects.toString(headerParameter)); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients().call(enumHeaderChannel, _request.build(), enumHeaderDeserializer); } @@ -846,11 +683,6 @@ public ListenableFuture jsonErrorsHeader(AuthHeader authHeader, String h _request.putHeaderParams("Authorization", authHeader.toString()); _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", _plainSerDe.serializeString(headerParameter)); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients().call(jsonErrorsHeaderChannel, _request.build(), jsonErrorsHeaderDeserializer); } @@ -860,11 +692,6 @@ public ListenableFuture errorParameterSerialization(AuthHeader authHeade _request.putHeaderParams("Authorization", authHeader.toString()); _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", _plainSerDe.serializeString(headerParameter)); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients() .call( errorParameterSerializationChannel, @@ -881,11 +708,6 @@ public ListenableFuture> aliasLongEndpoint( _request.putQueryParams( "input", Objects.toString(input.get().get())); } - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients() .call(aliasLongEndpointChannel, _request.build(), aliasLongEndpointDeserializer); } @@ -909,11 +731,6 @@ public ListenableFuture complexQueryParameters( for (int intsElement : ints) { _request.putQueryParams("ints", _plainSerDe.serializeInteger(intsElement)); } - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients() .call(complexQueryParametersChannel, _request.build(), complexQueryParametersDeserializer); } @@ -923,11 +740,6 @@ public ListenableFuture receiveListOfOptionals(AuthHeader authHeader, List Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(receiveListOfOptionalsSerializer.serialize(value)); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients() .call(receiveListOfOptionalsChannel, _request.build(), receiveListOfOptionalsDeserializer); } @@ -937,11 +749,6 @@ public ListenableFuture receiveSetOfOptionals(AuthHeader authHeader, Set receiveListOfStrings(AuthHeader authHeader, List stringDeserializer = - _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + _runtime.bodySerDe().deserializer(new TypeMarker() {}); private final EndpointChannel integerChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.integer); private final Deserializer integerDeserializer = - _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + _runtime.bodySerDe().deserializer(new TypeMarker() {}); private final EndpointChannel double_Channel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.double_); private final Deserializer double_Deserializer = - _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + _runtime.bodySerDe().deserializer(new TypeMarker() {}); private final EndpointChannel boolean_Channel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.boolean_); private final Deserializer boolean_Deserializer = - _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + _runtime.bodySerDe().deserializer(new TypeMarker() {}); private final EndpointChannel safelongChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.safelong); private final Deserializer safelongDeserializer = - _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + _runtime.bodySerDe().deserializer(new TypeMarker() {}); private final EndpointChannel ridChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.rid); - private final Deserializer ridDeserializer = _runtime.bodySerDe() - .deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final Deserializer ridDeserializer = + _runtime.bodySerDe().deserializer(new TypeMarker() {}); private final EndpointChannel bearertokenChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.bearertoken); - private final Deserializer bearertokenDeserializer = _runtime.bodySerDe() - .deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final Deserializer bearertokenDeserializer = + _runtime.bodySerDe().deserializer(new TypeMarker() {}); private final EndpointChannel optionalStringChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalString); - private final Deserializer> optionalStringDeserializer = _runtime.bodySerDe() - .deserializer(createExceptionDeserializerArgs(new TypeMarker>() {})); + private final Deserializer> optionalStringDeserializer = + _runtime.bodySerDe().deserializer(new TypeMarker>() {}); private final EndpointChannel optionalEmptyChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalEmpty); - private final Deserializer> optionalEmptyDeserializer = _runtime.bodySerDe() - .deserializer(createExceptionDeserializerArgs(new TypeMarker>() {})); + private final Deserializer> optionalEmptyDeserializer = + _runtime.bodySerDe().deserializer(new TypeMarker>() {}); private final EndpointChannel datetimeChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.datetime); - private final Deserializer datetimeDeserializer = _runtime.bodySerDe() - .deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final Deserializer datetimeDeserializer = + _runtime.bodySerDe().deserializer(new TypeMarker() {}); private final EndpointChannel binaryChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.binary); - private final Deserializer binaryDeserializer = _runtime.bodySerDe() - .inputStreamDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); - private final EndpointChannel pathChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.path); private final Deserializer pathDeserializer = - _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + _runtime.bodySerDe().deserializer(new TypeMarker() {}); private final EndpointChannel externalLongPathChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.externalLongPath); private final Deserializer externalLongPathDeserializer = - _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + _runtime.bodySerDe().deserializer(new TypeMarker() {}); private final EndpointChannel optionalExternalLongQueryChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalExternalLongQuery); - private final Deserializer> optionalExternalLongQueryDeserializer = _runtime.bodySerDe() - .deserializer(createExceptionDeserializerArgs(new TypeMarker>() {})); + private final Deserializer> optionalExternalLongQueryDeserializer = + _runtime.bodySerDe().deserializer(new TypeMarker>() {}); private final Serializer notNullBodySerializer = _runtime.bodySerDe().serializer(new TypeMarker() {}); @@ -302,26 +298,26 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con private final EndpointChannel notNullBodyChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.notNullBody); - private final Deserializer notNullBodyDeserializer = _runtime.bodySerDe() - .deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final Deserializer notNullBodyDeserializer = + _runtime.bodySerDe().deserializer(new TypeMarker() {}); private final EndpointChannel aliasOneChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.aliasOne); - private final Deserializer aliasOneDeserializer = _runtime.bodySerDe() - .deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final Deserializer aliasOneDeserializer = + _runtime.bodySerDe().deserializer(new TypeMarker() {}); private final EndpointChannel optionalAliasOneChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalAliasOne); - private final Deserializer optionalAliasOneDeserializer = _runtime.bodySerDe() - .deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final Deserializer optionalAliasOneDeserializer = + _runtime.bodySerDe().deserializer(new TypeMarker() {}); private final EndpointChannel aliasTwoChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.aliasTwo); - private final Deserializer aliasTwoDeserializer = _runtime.bodySerDe() - .deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final Deserializer aliasTwoDeserializer = + _runtime.bodySerDe().deserializer(new TypeMarker() {}); private final Serializer notNullBodyExternalImportSerializer = _runtime.bodySerDe() @@ -332,8 +328,7 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con private final Deserializer notNullBodyExternalImportDeserializer = _runtime.bodySerDe() - .deserializer(createExceptionDeserializerArgs( - new TypeMarker() {})); + .deserializer(new TypeMarker() {}); private final Serializer> optionalBodyExternalImportSerializer = _runtime.bodySerDe() @@ -345,72 +340,70 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con private final Deserializer> optionalBodyExternalImportDeserializer = _runtime.bodySerDe() - .deserializer(createExceptionDeserializerArgs( - new TypeMarker< - Optional>() {})); + .deserializer( + new TypeMarker>() {}); private final EndpointChannel optionalQueryExternalImportChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalQueryExternalImport); private final Deserializer> optionalQueryExternalImportDeserializer = _runtime.bodySerDe() - .deserializer(createExceptionDeserializerArgs( - new TypeMarker< - Optional>() {})); + .deserializer( + new TypeMarker>() {}); private final EndpointChannel noReturnChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.noReturn); - private final Deserializer noReturnDeserializer = _runtime.bodySerDe() - .emptyBodyDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final Deserializer noReturnDeserializer = + _runtime.bodySerDe().emptyBodyDeserializer(); private final EndpointChannel enumQueryChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.enumQuery); private final Deserializer enumQueryDeserializer = - _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + _runtime.bodySerDe().deserializer(new TypeMarker() {}); private final EndpointChannel enumListQueryChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.enumListQuery); - private final Deserializer> enumListQueryDeserializer = _runtime.bodySerDe() - .deserializer(createExceptionDeserializerArgs(new TypeMarker>() {})); + private final Deserializer> enumListQueryDeserializer = + _runtime.bodySerDe().deserializer(new TypeMarker>() {}); private final EndpointChannel optionalEnumQueryChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalEnumQuery); - private final Deserializer> optionalEnumQueryDeserializer = _runtime.bodySerDe() - .deserializer(createExceptionDeserializerArgs(new TypeMarker>() {})); + private final Deserializer> optionalEnumQueryDeserializer = + _runtime.bodySerDe().deserializer(new TypeMarker>() {}); private final EndpointChannel enumHeaderChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.enumHeader); private final Deserializer enumHeaderDeserializer = - _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + _runtime.bodySerDe().deserializer(new TypeMarker() {}); private final EndpointChannel jsonErrorsHeaderChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.jsonErrorsHeader); private final Deserializer jsonErrorsHeaderDeserializer = - _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + _runtime.bodySerDe().deserializer(new TypeMarker() {}); private final EndpointChannel errorParameterSerializationChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.errorParameterSerialization); private final Deserializer errorParameterSerializationDeserializer = - _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + _runtime.bodySerDe().deserializer(new TypeMarker() {}); private final EndpointChannel aliasLongEndpointChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.aliasLongEndpoint); - private final Deserializer> aliasLongEndpointDeserializer = _runtime.bodySerDe() - .deserializer(createExceptionDeserializerArgs(new TypeMarker>() {})); + private final Deserializer> aliasLongEndpointDeserializer = + _runtime.bodySerDe().deserializer(new TypeMarker>() {}); private final EndpointChannel complexQueryParametersChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.complexQueryParameters); - private final Deserializer complexQueryParametersDeserializer = _runtime.bodySerDe() - .emptyBodyDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final Deserializer complexQueryParametersDeserializer = + _runtime.bodySerDe().emptyBodyDeserializer(); private final Serializer>> receiveListOfOptionalsSerializer = _runtime.bodySerDe().serializer(new TypeMarker>>() {}); @@ -418,8 +411,8 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con private final EndpointChannel receiveListOfOptionalsChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.receiveListOfOptionals); - private final Deserializer receiveListOfOptionalsDeserializer = _runtime.bodySerDe() - .emptyBodyDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final Deserializer receiveListOfOptionalsDeserializer = + _runtime.bodySerDe().emptyBodyDeserializer(); private final Serializer>> receiveSetOfOptionalsSerializer = _runtime.bodySerDe().serializer(new TypeMarker>>() {}); @@ -427,8 +420,8 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con private final EndpointChannel receiveSetOfOptionalsChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.receiveSetOfOptionals); - private final Deserializer receiveSetOfOptionalsDeserializer = _runtime.bodySerDe() - .emptyBodyDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final Deserializer receiveSetOfOptionalsDeserializer = + _runtime.bodySerDe().emptyBodyDeserializer(); private final Serializer> receiveListOfStringsSerializer = _runtime.bodySerDe().serializer(new TypeMarker>() {}); @@ -436,48 +429,13 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con private final EndpointChannel receiveListOfStringsChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.receiveListOfStrings); - private final Deserializer receiveListOfStringsDeserializer = _runtime.bodySerDe() - .emptyBodyDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); - - private ExceptionDeserializerArgs createExceptionDeserializerArgs(TypeMarker returnType) { - return ExceptionDeserializerArgs.builder() - .returnType(returnType) - .exception( - ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_SERVICE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureErrors.INVALID_TYPE_DEFINITION.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .exception( - ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), - new TypeMarker() {}, - new TypeMarker() {}) - .build(); - } + private final Deserializer receiveListOfStringsDeserializer = + _runtime.bodySerDe().emptyBodyDeserializer(); @Override public String string(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients().callBlocking(stringChannel, _request.build(), stringDeserializer); } @@ -485,11 +443,6 @@ public String string(AuthHeader authHeader) { public int integer(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients().callBlocking(integerChannel, _request.build(), integerDeserializer); } @@ -497,11 +450,6 @@ public int integer(AuthHeader authHeader) { public double double_(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients().callBlocking(double_Channel, _request.build(), double_Deserializer); } @@ -509,11 +457,6 @@ public double double_(AuthHeader authHeader) { public boolean boolean_(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients().callBlocking(boolean_Channel, _request.build(), boolean_Deserializer); } @@ -521,11 +464,6 @@ public boolean boolean_(AuthHeader authHeader) { public SafeLong safelong(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients().callBlocking(safelongChannel, _request.build(), safelongDeserializer); } @@ -533,11 +471,6 @@ public SafeLong safelong(AuthHeader authHeader) { public ResourceIdentifier rid(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients().callBlocking(ridChannel, _request.build(), ridDeserializer); } @@ -545,11 +478,6 @@ public ResourceIdentifier rid(AuthHeader authHeader) { public BearerToken bearertoken(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients().callBlocking(bearertokenChannel, _request.build(), bearertokenDeserializer); } @@ -557,11 +485,6 @@ public BearerToken bearertoken(AuthHeader authHeader) { public Optional optionalString(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients() .callBlocking(optionalStringChannel, _request.build(), optionalStringDeserializer); } @@ -570,11 +493,6 @@ public Optional optionalString(AuthHeader authHeader) { public Optional optionalEmpty(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients() .callBlocking(optionalEmptyChannel, _request.build(), optionalEmptyDeserializer); } @@ -583,11 +501,6 @@ public Optional optionalEmpty(AuthHeader authHeader) { public OffsetDateTime datetime(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients().callBlocking(datetimeChannel, _request.build(), datetimeDeserializer); } @@ -595,12 +508,11 @@ public OffsetDateTime datetime(AuthHeader authHeader) { public InputStream binary(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } - return _runtime.clients().callBlocking(binaryChannel, _request.build(), binaryDeserializer); + return _runtime.clients() + .callBlocking( + binaryChannel, + _request.build(), + _runtime.bodySerDe().inputStreamDeserializer()); } @Override @@ -608,11 +520,6 @@ public String path(AuthHeader authHeader, String param) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("param", _plainSerDe.serializeString(param)); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients().callBlocking(pathChannel, _request.build(), pathDeserializer); } @@ -621,11 +528,6 @@ public long externalLongPath(AuthHeader authHeader, long param) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("param", Objects.toString(param)); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients() .callBlocking(externalLongPathChannel, _request.build(), externalLongPathDeserializer); } @@ -637,11 +539,6 @@ public Optional optionalExternalLongQuery(AuthHeader authHeader, Optional< if (param.isPresent()) { _request.putQueryParams("param", Objects.toString(param.get())); } - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients() .callBlocking( optionalExternalLongQueryChannel, @@ -654,11 +551,6 @@ public StringAliasExample notNullBody(AuthHeader authHeader, StringAliasExample Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(notNullBodySerializer.serialize(notNullBody)); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients().callBlocking(notNullBodyChannel, _request.build(), notNullBodyDeserializer); } @@ -667,11 +559,6 @@ public StringAliasExample aliasOne(AuthHeader authHeader, StringAliasExample que Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putQueryParams("queryParamName", _plainSerDe.serializeString(queryParamName.get())); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients().callBlocking(aliasOneChannel, _request.build(), aliasOneDeserializer); } @@ -685,11 +572,6 @@ public StringAliasExample optionalAliasOne( "queryParamName", _plainSerDe.serializeString(queryParamName.get().get())); } - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients() .callBlocking(optionalAliasOneChannel, _request.build(), optionalAliasOneDeserializer); } @@ -701,11 +583,6 @@ public NestedStringAliasExample aliasTwo(AuthHeader authHeader, NestedStringAlia _request.putQueryParams( "queryParamName", _plainSerDe.serializeString(queryParamName.get().get())); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients().callBlocking(aliasTwoChannel, _request.build(), aliasTwoDeserializer); } @@ -715,11 +592,6 @@ public allexamples.com.palantir.product.StringAliasExample notNullBodyExternalIm Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(notNullBodyExternalImportSerializer.serialize(notNullBody)); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients() .callBlocking( notNullBodyExternalImportChannel, @@ -733,11 +605,6 @@ public Optional optionalBod Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(optionalBodyExternalImportSerializer.serialize(body)); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients() .callBlocking( optionalBodyExternalImportChannel, @@ -753,11 +620,6 @@ public Optional optionalQue if (query.isPresent()) { _request.putQueryParams("query", Objects.toString(query.get())); } - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients() .callBlocking( optionalQueryExternalImportChannel, @@ -769,11 +631,6 @@ public Optional optionalQue public void noReturn(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } _runtime.clients().callBlocking(noReturnChannel, _request.build(), noReturnDeserializer); } @@ -782,11 +639,6 @@ public SimpleEnum enumQuery(AuthHeader authHeader, SimpleEnum queryParamName) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putQueryParams("queryParamName", Objects.toString(queryParamName)); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients().callBlocking(enumQueryChannel, _request.build(), enumQueryDeserializer); } @@ -797,11 +649,6 @@ public List enumListQuery(AuthHeader authHeader, List qu for (SimpleEnum queryParamNameElement : queryParamName) { _request.putQueryParams("queryParamName", Objects.toString(queryParamNameElement)); } - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients() .callBlocking(enumListQueryChannel, _request.build(), enumListQueryDeserializer); } @@ -813,11 +660,6 @@ public Optional optionalEnumQuery(AuthHeader authHeader, Optional aliasLongEndpoint(AuthHeader authHeader, Optional> Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(receiveListOfOptionalsSerializer.serialize(value)); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } _runtime.clients() .callBlocking( receiveListOfOptionalsChannel, _request.build(), receiveListOfOptionalsDeserializer); @@ -934,11 +746,6 @@ public void receiveSetOfOptionals(AuthHeader authHeader, Set> v Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(receiveSetOfOptionalsSerializer.serialize(value)); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } _runtime.clients() .callBlocking( receiveSetOfOptionalsChannel, _request.build(), receiveSetOfOptionalsDeserializer); @@ -949,11 +756,6 @@ public void receiveListOfStrings(AuthHeader authHeader, List value) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(receiveListOfStringsSerializer.serialize(value)); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } _runtime.clients() .callBlocking(receiveListOfStringsChannel, _request.build(), receiveListOfStringsDeserializer); } diff --git a/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceAsync.java b/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceAsync.java index 8e3b7ca3c..835e97b78 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceAsync.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceAsync.java @@ -10,10 +10,8 @@ import com.palantir.dialogue.Endpoint; import com.palantir.dialogue.EndpointChannel; import com.palantir.dialogue.EndpointChannelFactory; -import com.palantir.dialogue.ExceptionDeserializerArgs; import com.palantir.dialogue.PlainSerDe; import com.palantir.dialogue.Request; -import com.palantir.dialogue.TypeMarker; import com.palantir.tokens.auth.BearerToken; import java.lang.Override; import java.lang.String; @@ -35,24 +33,13 @@ static CookieServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Con private final EndpointChannel eatCookiesChannel = _endpointChannelFactory.endpoint(DialogueCookieEndpoints.eatCookies); - private final Deserializer eatCookiesDeserializer = _runtime.bodySerDe() - .emptyBodyDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); - - private ExceptionDeserializerArgs createExceptionDeserializerArgs(TypeMarker returnType) { - return ExceptionDeserializerArgs.builder() - .returnType(returnType) - .build(); - } + private final Deserializer eatCookiesDeserializer = + _runtime.bodySerDe().emptyBodyDeserializer(); @Override public ListenableFuture eatCookies(BearerToken token) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Cookie", "PALANTIR_TOKEN=" + _plainSerDe.serializeBearerToken(token)); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } return _runtime.clients().call(eatCookiesChannel, _request.build(), eatCookiesDeserializer); } diff --git a/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceBlocking.java b/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceBlocking.java index 6411b609a..78e6e8cc0 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceBlocking.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceBlocking.java @@ -9,10 +9,8 @@ import com.palantir.dialogue.Endpoint; import com.palantir.dialogue.EndpointChannel; import com.palantir.dialogue.EndpointChannelFactory; -import com.palantir.dialogue.ExceptionDeserializerArgs; import com.palantir.dialogue.PlainSerDe; import com.palantir.dialogue.Request; -import com.palantir.dialogue.TypeMarker; import com.palantir.tokens.auth.BearerToken; import java.lang.Override; import java.lang.String; @@ -34,24 +32,13 @@ static CookieServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, private final EndpointChannel eatCookiesChannel = _endpointChannelFactory.endpoint(DialogueCookieEndpoints.eatCookies); - private final Deserializer eatCookiesDeserializer = _runtime.bodySerDe() - .emptyBodyDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); - - private ExceptionDeserializerArgs createExceptionDeserializerArgs(TypeMarker returnType) { - return ExceptionDeserializerArgs.builder() - .returnType(returnType) - .build(); - } + private final Deserializer eatCookiesDeserializer = + _runtime.bodySerDe().emptyBodyDeserializer(); @Override public void eatCookies(BearerToken token) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Cookie", "PALANTIR_TOKEN=" + _plainSerDe.serializeBearerToken(token)); - if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { - _request.putHeaderParams( - "Accept-Conjure-Error-Parameter-Format", - _runtime.bodySerDe().errorParameterFormat().get().toString()); - } _runtime.clients().callBlocking(eatCookiesChannel, _request.build(), eatCookiesDeserializer); } diff --git a/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowServiceEteTest.java b/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowServiceEteTest.java index 21f334d4f..6845be536 100644 --- a/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowServiceEteTest.java +++ b/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowServiceEteTest.java @@ -37,7 +37,6 @@ import com.palantir.dialogue.clients.DialogueClients; import com.palantir.ri.ResourceIdentifier; import com.palantir.tokens.auth.AuthHeader; -import dialogue.com.palantir.product.ConjureErrors.ErrorWithComplexArgsException; import dialogue.com.palantir.product.EteBinaryServiceBlocking; import dialogue.com.palantir.product.EteServiceAsync; import dialogue.com.palantir.product.EteServiceBlocking; @@ -589,10 +588,11 @@ public void testStringParametersDoNotChangeWhenUsingJsonAndJavaString() { // .getError() returns the SerializableError which should contain the legacy parameters sent over the wire. jsonParams = e.getError().parameters(); // e should be an instance of ErrorWithComplexArgsException, which has rich parameters as well. - assertThat(e.getCause()).isInstanceOfSatisfying(ErrorWithComplexArgsException.class, exception -> { - assertThat(exception.error().parameters().optionalExample().getOptionalString()) - .contains("optional-value"); - }); + // assertThat(e.getCause()).isInstanceOfSatisfying(ErrorWithComplexArgsException.class, exception + // -> { + // assertThat(exception.error().parameters().optionalExample().getOptionalString()) + // .contains("optional-value"); + // }); } // Assert that the two maps contain the same keys and values, except for the `primitiveExample` and `anyExample` diff --git a/conjure-java-core/src/test/java/com/palantir/conjure/java/parameterized/TestCases.java b/conjure-java-core/src/test/java/com/palantir/conjure/java/parameterized/TestCases.java index b6600982f..ee8f89eb8 100644 --- a/conjure-java-core/src/test/java/com/palantir/conjure/java/parameterized/TestCases.java +++ b/conjure-java-core/src/test/java/com/palantir/conjure/java/parameterized/TestCases.java @@ -176,10 +176,7 @@ public final class TestCases { .files(Path.of("ete-service.yml")) .files(Path.of("ete-binary.yml")) .files(Path.of("example-errors.yml")) - .options(Options.builder() - .apiVersion("1.2.3") - .generateErrorParameterFormatRespectingDialogueInterfaces(true) - .build()) + .options(Options.builder().apiVersion("1.2.3").build()) .generatorTypes(List.of(GeneratorType.DIALOGUE, GeneratorType.OBJECT, GeneratorType.ERROR)) .build()) .add(ParameterizedTestCase.builder() From d26910cdeefedcf74cf221b093d1809b33782d83 Mon Sep 17 00:00:00 2001 From: Pritham Marupaka Date: Thu, 28 Aug 2025 16:25:12 -0400 Subject: [PATCH 20/26] review changes --- .../product/DialogueEteEndpoints.java | 4 +- .../com/palantir/product/EteServiceAsync.java | 4 +- .../palantir/product/EteServiceBlocking.java | 4 +- .../com/palantir/product/EteService.java | 4 +- .../palantir/product/UndertowEteService.java | 4 +- .../DefaultStaticFactoryMethodGenerator.java | 41 +++++++++---------- .../dialogue/DialogueServiceGenerator.java | 7 +--- .../java/util/ErrorGenerationUtils.java | 26 ------------ .../ParameterizedConjureGenerationTest.java | 2 - .../src/test/resources/ete-service.yml | 5 ++- .../conjure/java/cli/ConjureJavaCli.java | 2 +- versions.props | 2 +- 12 files changed, 36 insertions(+), 69 deletions(-) diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/DialogueEteEndpoints.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/DialogueEteEndpoints.java index 0009b2c0f..7d2e7b517 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/DialogueEteEndpoints.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/DialogueEteEndpoints.java @@ -883,8 +883,8 @@ public String version() { }, /** - * This endpoint is used to test that that error parameters serialized as JSON or using Objects.toString - * are both handled correctly by the clients that return "rich" exceptions (which are sub-types of + * This endpoint is used to test that error parameters serialized as JSON or using Objects.toString are + * both handled correctly by the clients that can deserialize "rich" exceptions (which are sub-types of * RemoteException). */ errorParameterSerialization { diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceAsync.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceAsync.java index e4f65beff..061a89312 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceAsync.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceAsync.java @@ -177,8 +177,8 @@ ListenableFuture> optionalEnumQuery( ListenableFuture jsonErrorsHeader(AuthHeader authHeader, String headerParameter); /** - * This endpoint is used to test that that error parameters serialized as JSON or using Objects.toString - * are both handled correctly by the clients that return "rich" exceptions (which are sub-types of + * This endpoint is used to test that error parameters serialized as JSON or using Objects.toString are + * both handled correctly by the clients that can deserialize "rich" exceptions (which are sub-types of * RemoteException). * * @apiNote {@code GET /base/errors/serialization} diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceBlocking.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceBlocking.java index 520b57a98..9ec603f06 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceBlocking.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceBlocking.java @@ -176,8 +176,8 @@ Optional optionalQueryExter String jsonErrorsHeader(AuthHeader authHeader, String headerParameter); /** - * This endpoint is used to test that that error parameters serialized as JSON or using Objects.toString - * are both handled correctly by the clients that return "rich" exceptions (which are sub-types of + * This endpoint is used to test that error parameters serialized as JSON or using Objects.toString are + * both handled correctly by the clients that can deserialize "rich" exceptions (which are sub-types of * RemoteException). * * @apiNote {@code GET /base/errors/serialization} diff --git a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/EteService.java b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/EteService.java index d502ff1ef..a6b10b1ac 100644 --- a/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/EteService.java +++ b/conjure-java-core/src/integrationInput/java/jersey/com/palantir/product/EteService.java @@ -212,8 +212,8 @@ String jsonErrorsHeader( @HeaderParam("Accept-Conjure-Error-Parameter-Format") String headerParameter); /** - * This endpoint is used to test that that error parameters serialized as JSON or using Objects.toString - * are both handled correctly by the clients that return "rich" exceptions (which are sub-types of + * This endpoint is used to test that error parameters serialized as JSON or using Objects.toString are + * both handled correctly by the clients that can deserialize "rich" exceptions (which are sub-types of * RemoteException). */ @GET diff --git a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/UndertowEteService.java b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/UndertowEteService.java index 380029e20..49317a936 100644 --- a/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/UndertowEteService.java +++ b/conjure-java-core/src/integrationInput/java/undertow/com/palantir/product/UndertowEteService.java @@ -125,8 +125,8 @@ Optional optionalQueryExter String jsonErrorsHeader(AuthHeader authHeader, String headerParameter); /** - * This endpoint is used to test that that error parameters serialized as JSON or using Objects.toString - * are both handled correctly by the clients that return "rich" exceptions (which are sub-types of + * This endpoint is used to test that error parameters serialized as JSON or using Objects.toString are + * both handled correctly by the clients that can deserialize "rich" exceptions (which are sub-types of * RemoteException). * * @apiNote {@code GET /base/errors/serialization} diff --git a/conjure-java-core/src/main/java/com/palantir/conjure/java/services/dialogue/DefaultStaticFactoryMethodGenerator.java b/conjure-java-core/src/main/java/com/palantir/conjure/java/services/dialogue/DefaultStaticFactoryMethodGenerator.java index 4af1c6177..28e30c717 100644 --- a/conjure-java-core/src/main/java/com/palantir/conjure/java/services/dialogue/DefaultStaticFactoryMethodGenerator.java +++ b/conjure-java-core/src/main/java/com/palantir/conjure/java/services/dialogue/DefaultStaticFactoryMethodGenerator.java @@ -18,9 +18,9 @@ import com.google.common.base.CaseFormat; import com.google.common.collect.ImmutableMap; import com.palantir.conjure.java.Options; +import com.palantir.conjure.java.api.errors.ConjureErrorParameterFormats; import com.palantir.conjure.java.services.Auth; import com.palantir.conjure.java.util.ErrorGenerationUtils; -import com.palantir.conjure.java.util.ErrorGenerationUtils.PackageToErrorDefinitionsMapping; import com.palantir.conjure.java.util.Packages; import com.palantir.conjure.java.util.Primitives; import com.palantir.conjure.spec.ArgumentDefinition; @@ -82,7 +82,7 @@ public final class DefaultStaticFactoryMethodGenerator implements StaticFactoryM private final ParameterTypeMapper parameterTypes; private final ReturnTypeMapper returnTypes; private final StaticFactoryMethodType methodType; - private final PackageToErrorDefinitionsMapping packageToErrorDefinitionsMapping; + private final List errorDefinitions; public DefaultStaticFactoryMethodGenerator( Options options, @@ -90,13 +90,13 @@ public DefaultStaticFactoryMethodGenerator( ParameterTypeMapper parameterTypes, ReturnTypeMapper returnTypes, StaticFactoryMethodType methodType, - PackageToErrorDefinitionsMapping packageToErrorDefinitionsMapping) { + List errorDefinitions) { this.options = options; this.typeNameResolver = typeNameResolver; this.parameterTypes = parameterTypes; this.returnTypes = returnTypes; this.methodType = methodType; - this.packageToErrorDefinitionsMapping = packageToErrorDefinitionsMapping; + this.errorDefinitions = errorDefinitions; } @Override @@ -110,8 +110,7 @@ public MethodSpec generate(ServiceDefinition def) { .build()); if (options.generateErrorParameterFormatRespectingDialogueInterfaces()) { - impl.addMethod(createHelperToConstructExceptionDeserializerArgs( - def.getServiceName().getPackage())); + impl.addMethod(createHelperToConstructExceptionDeserializerArgs()); } def.getEndpoints().forEach(endpoint -> { @@ -142,8 +141,14 @@ public MethodSpec generate(ServiceDefinition def) { return method; } - private MethodSpec createHelperToConstructExceptionDeserializerArgs(String serviceDefinitionPackageName) { - List errorDefinitions = packageToErrorDefinitionsMapping.get(serviceDefinitionPackageName); + private ClassName getClassNameInErrorsPackage(ErrorDefinition errorDef, String name) { + return ClassName.get( + Packages.getPrefixedPackage(errorDef.getErrorName().getPackage(), options.packagePrefix()), + ErrorGenerationUtils.errorTypesClassName(errorDef.getNamespace()), + name); + } + + private MethodSpec createHelperToConstructExceptionDeserializerArgs() { TypeVariableName typeVariableT = TypeVariableName.get("T"); MethodSpec.Builder methodBuilder = MethodSpec.methodBuilder("createExceptionDeserializerArgs") .addTypeVariable(typeVariableT) @@ -157,18 +162,10 @@ private MethodSpec createHelperToConstructExceptionDeserializerArgs(String servi // Add exceptions from error definitions for (ErrorDefinition errorDef : errorDefinitions) { String errorName = errorDef.getErrorName().getName(); - ClassName errorClass = ClassName.get( - Packages.getPrefixedPackage(errorDef.getErrorName().getPackage(), options.packagePrefix()), - ErrorGenerationUtils.errorTypesClassName(errorDef.getNamespace()), - CaseFormat.UPPER_CAMEL.to(CaseFormat.UPPER_UNDERSCORE, errorName)); - ClassName serializableErrorClass = ClassName.get( - Packages.getPrefixedPackage(errorDef.getErrorName().getPackage(), options.packagePrefix()), - ErrorGenerationUtils.errorTypesClassName(errorDef.getNamespace()), - errorName + "SerializableError"); - ClassName exceptionClass = ClassName.get( - Packages.getPrefixedPackage(errorDef.getErrorName().getPackage(), options.packagePrefix()), - ErrorGenerationUtils.errorTypesClassName(errorDef.getNamespace()), - errorName + "Exception"); + ClassName errorClass = getClassNameInErrorsPackage( + errorDef, CaseFormat.UPPER_CAMEL.to(CaseFormat.UPPER_UNDERSCORE, errorName)); + ClassName serializableErrorClass = getClassNameInErrorsPackage(errorDef, errorName + "SerializableError"); + ClassName exceptionClass = getClassNameInErrorsPackage(errorDef, errorName + "Exception"); exceptions.add( ".exception($T.name(), new $T<$T>() {}, new $T<$T>() {})", errorClass, @@ -308,9 +305,9 @@ private MethodSpec clientImpl(EndpointDefinition def) { methodBuilder.addCode(CodeBlock.builder() .beginControlFlow("if ($L.bodySerDe().errorParameterFormat().isPresent())", RUNTIME) .add( - "$L.putHeaderParams($S," + " $L.bodySerDe().errorParameterFormat().get().toString());", + "$L.putHeaderParams($S, $L.bodySerDe().errorParameterFormat().get().toString());", REQUEST, - "Accept-Conjure-Error-Parameter-Format", // TODO(pm): make this public. + ConjureErrorParameterFormats.ACCEPT_CONJURE_ERROR_PARAMETER_FORMAT_HEADER, RUNTIME) .endControlFlow() .build()); diff --git a/conjure-java-core/src/main/java/com/palantir/conjure/java/services/dialogue/DialogueServiceGenerator.java b/conjure-java-core/src/main/java/com/palantir/conjure/java/services/dialogue/DialogueServiceGenerator.java index 2bc4cf804..bd21f72df 100644 --- a/conjure-java-core/src/main/java/com/palantir/conjure/java/services/dialogue/DialogueServiceGenerator.java +++ b/conjure-java-core/src/main/java/com/palantir/conjure/java/services/dialogue/DialogueServiceGenerator.java @@ -22,7 +22,6 @@ import com.palantir.conjure.java.types.SafetyEvaluator; import com.palantir.conjure.java.types.SpecializeBinaryClassNameVisitor; import com.palantir.conjure.java.types.TypeMapper; -import com.palantir.conjure.java.util.ErrorGenerationUtils.PackageToErrorDefinitionsMapping; import com.palantir.conjure.java.util.TypeFunctions; import com.palantir.conjure.spec.ConjureDefinition; import com.palantir.conjure.spec.ServiceDefinition; @@ -71,15 +70,13 @@ public Stream generate(ConjureDefinition conjureDefinition) { TypeNameResolver typeNameResolver = typeName -> Preconditions.checkNotNull( types.get(typeName), "Referenced unknown TypeName", SafeArg.of("typeName", typeName)); - PackageToErrorDefinitionsMapping packageToErrorDefinitionsMapping = - PackageToErrorDefinitionsMapping.from(conjureDefinition); StaticFactoryMethodGenerator asyncGenerator = new DefaultStaticFactoryMethodGenerator( options, typeNameResolver, parameterMapper, new ReturnTypeMapper(returnTypes), StaticFactoryMethodType.ASYNC, - packageToErrorDefinitionsMapping); + conjureDefinition.getErrors()); StaticFactoryMethodGenerator blockingGenerator = new DefaultStaticFactoryMethodGenerator( options, @@ -87,7 +84,7 @@ public Stream generate(ConjureDefinition conjureDefinition) { parameterMapper, new ReturnTypeMapper(returnTypes), StaticFactoryMethodType.BLOCKING, - packageToErrorDefinitionsMapping); + conjureDefinition.getErrors()); return conjureDefinition.getServices().stream() .flatMap(serviceDef -> generateFilesForService( diff --git a/conjure-java-core/src/main/java/com/palantir/conjure/java/util/ErrorGenerationUtils.java b/conjure-java-core/src/main/java/com/palantir/conjure/java/util/ErrorGenerationUtils.java index 7cf0c4d87..3cfe96962 100644 --- a/conjure-java-core/src/main/java/com/palantir/conjure/java/util/ErrorGenerationUtils.java +++ b/conjure-java-core/src/main/java/com/palantir/conjure/java/util/ErrorGenerationUtils.java @@ -67,32 +67,6 @@ public static String errorParametersClassName(String errorName) { return errorName + "Parameters"; } - public static ParameterSpec buildParameterWithSafetyAnnotationAndJsonProperty( - TypeMapper typeMapper, FieldDefinition argDefinition, boolean isSafe) { - ParameterSpec.Builder parameterBuilder = - buildParameterWithSafetyAnnotationInternal(typeMapper, argDefinition, isSafe, true); - parameterBuilder.addAnnotation(AnnotationSpec.builder(JsonProperty.class) - .addMember("value", "$S", argDefinition.getFieldName().get()) - .build()); - return parameterBuilder.build(); - } - - /** - * A mapping from a package name to the list of errors defined within that package. This is used when attempting to - * deserialize error responses from endpoints. - */ - public record PackageToErrorDefinitionsMapping(Map> packageToErrors) { - public static PackageToErrorDefinitionsMapping from(ConjureDefinition definition) { - Map> fromDefinition = definition.getErrors().stream() - .collect(Collectors.groupingBy(error -> error.getErrorName().getPackage(), Collectors.toList())); - return new PackageToErrorDefinitionsMapping(fromDefinition); - } - - public List get(String packageName) { - return packageToErrors.getOrDefault(packageName, ImmutableList.of()); - } - } - public record DeclaredEndpointErrors(Set errors) { public static DeclaredEndpointErrors from(ConjureDefinition definition) { return new DeclaredEndpointErrors(definition.getServices().stream() diff --git a/conjure-java-core/src/test/java/com/palantir/conjure/java/parameterized/ParameterizedConjureGenerationTest.java b/conjure-java-core/src/test/java/com/palantir/conjure/java/parameterized/ParameterizedConjureGenerationTest.java index 87c7961b3..82dfe465d 100644 --- a/conjure-java-core/src/test/java/com/palantir/conjure/java/parameterized/ParameterizedConjureGenerationTest.java +++ b/conjure-java-core/src/test/java/com/palantir/conjure/java/parameterized/ParameterizedConjureGenerationTest.java @@ -33,7 +33,6 @@ import java.util.Set; import java.util.stream.Collectors; import java.util.stream.Stream; -import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.MethodOrderer; import org.junit.jupiter.api.Order; import org.junit.jupiter.api.Test; @@ -69,7 +68,6 @@ void testGeneratedCode(ParameterizedTestCase testCase) throws IOException { @Test @Order(2) - @Disabled void validateOnlyRegisteredPackagesPresent() { File referenceFilesFolder = new File(REFERENCE_FILES_FOLDER); File[] files = referenceFilesFolder.listFiles(); diff --git a/conjure-java-core/src/test/resources/ete-service.yml b/conjure-java-core/src/test/resources/ete-service.yml index 9f82a7ff7..be68e6fe4 100644 --- a/conjure-java-core/src/test/resources/ete-service.yml +++ b/conjure-java-core/src/test/resources/ete-service.yml @@ -220,8 +220,9 @@ services: errorParameterSerialization: http: GET /errors/serialization docs: | - This endpoint is used to test that that error parameters serialized as JSON or using `Objects.toString` are - both handled correctly by the clients that return "rich" exceptions (which are sub-types of `RemoteException`). + This endpoint is used to test that error parameters serialized as JSON or using `Objects.toString` are + both handled correctly by the clients that can deserialize "rich" exceptions (which are sub-types of + `RemoteException`). args: headerParameter: param-type: header diff --git a/conjure-java/src/main/java/com/palantir/conjure/java/cli/ConjureJavaCli.java b/conjure-java/src/main/java/com/palantir/conjure/java/cli/ConjureJavaCli.java index 7209a789e..e0abd56cd 100644 --- a/conjure-java/src/main/java/com/palantir/conjure/java/cli/ConjureJavaCli.java +++ b/conjure-java/src/main/java/com/palantir/conjure/java/cli/ConjureJavaCli.java @@ -252,7 +252,7 @@ public static final class GenerateCommand implements Runnable { description = "Enabling this flag will lead to the generation of Dialogue client interfaces that are able to" + " send a header to servers specifying the Conjure error parameter serialization format" - + " they expect, and create custom exceptions foreach error defined in the service's" + + " they expect, and create custom exceptions for each error defined in the service's" + " package.") private boolean generateErrorParameterFormatRespectingDialogueInterfaces; diff --git a/versions.props b/versions.props index 93ea46cbf..26d5d59ae 100644 --- a/versions.props +++ b/versions.props @@ -11,8 +11,8 @@ com.palantir.conjure.java.runtime:* = 8.24.0 com.palantir.conjure.verification:* = 0.19.0 com.palantir.conjure:* = 4.50.0 com.palantir.deadlines:* = 0.15.0 -com.palantir.goethe:* = 0.16.0 com.palantir.dialogue:* = 6.8.0-7-gde83dba +com.palantir.goethe:* = 0.16.0 com.palantir.human-readable-types:* = 1.7.0 com.palantir.javapoet:javapoet = 0.7.0 com.palantir.ri:resource-identifier = 2.11.0 From 2c8a4d26f9e8c4e477f726739b9335a48b04ba69 Mon Sep 17 00:00:00 2001 From: Pritham Marupaka Date: Sun, 7 Sep 2025 19:08:18 -0400 Subject: [PATCH 21/26] Use SerailizableErrorProvider --- .../conjure/java/types/ErrorGenerator.java | 19 +++++++++----- versions.lock | 26 +++++++++---------- versions.props | 2 +- 3 files changed, 27 insertions(+), 20 deletions(-) diff --git a/conjure-java-core/src/main/java/com/palantir/conjure/java/types/ErrorGenerator.java b/conjure-java-core/src/main/java/com/palantir/conjure/java/types/ErrorGenerator.java index 91ed757d8..b5ff47a21 100644 --- a/conjure-java-core/src/main/java/com/palantir/conjure/java/types/ErrorGenerator.java +++ b/conjure-java-core/src/main/java/com/palantir/conjure/java/types/ErrorGenerator.java @@ -27,6 +27,7 @@ import com.palantir.conjure.java.api.errors.ErrorType; import com.palantir.conjure.java.api.errors.RemoteException; import com.palantir.conjure.java.api.errors.SerializableError; +import com.palantir.conjure.java.api.errors.SerializableErrorProvider; import com.palantir.conjure.java.api.errors.ServiceException; import com.palantir.conjure.java.util.ErrorGenerationUtils; import com.palantir.conjure.java.util.ErrorGenerationUtils.DeclaredEndpointErrors; @@ -164,7 +165,8 @@ private JavaFile generateErrorTypesForNamespace( }) .collect(Collectors.toList()); - TypeSpec.Builder typeBuilder = TypeSpec.classBuilder(errorTypesClassName(conjurePackage, namespace)) + ClassName errorsClassName = errorTypesClassName(conjurePackage, namespace); + TypeSpec.Builder typeBuilder = TypeSpec.classBuilder(errorsClassName) .addMethod(ErrorGenerationUtils.privateConstructor()) .addModifiers(Modifier.PUBLIC, Modifier.FINAL) .addFields(generateErrorTypeFields(namespace, errorTypeDefinitions)) @@ -176,7 +178,7 @@ private JavaFile generateErrorTypesForNamespace( typeBuilder .addTypes(generateErrorParameterRecords(errorTypeDefinitions, typeMapper)) .addTypes(generateSerializableErrors(errorTypeDefinitions)) - .addTypes(generateRemoteExceptionTypes(errorTypeDefinitions)); + .addTypes(generateRemoteExceptionTypes(errorsClassName, errorTypeDefinitions)); } return JavaFile.builder(conjurePackage, typeBuilder.build()) @@ -185,20 +187,25 @@ private JavaFile generateErrorTypesForNamespace( .build(); } - private static List generateRemoteExceptionTypes(List errorDefinitions) { + private static List generateRemoteExceptionTypes( + ClassName errorsClassName, List errorDefinitions) { return errorDefinitions.stream() - .map(ErrorGenerator::generateRemoteExceptionType) + .map(def -> generateRemoteExceptionType(errorsClassName, def)) .toList(); } - private static TypeSpec generateRemoteExceptionType(ErrorDefinition errorDefinition) { + private static TypeSpec generateRemoteExceptionType(ClassName errorsClassName, ErrorDefinition errorDefinition) { String remoteExceptionClassName = errorDefinition.getErrorName().getName() + "Exception"; ClassName serializableErrorClassName = - ClassName.get("", errorDefinition.getErrorName().getName() + "SerializableError"); + errorsClassName.nestedClass(errorDefinition.getErrorName().getName() + "SerializableError"); TypeSpec.Builder classBuilder = TypeSpec.classBuilder(remoteExceptionClassName) .addModifiers(Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL) .superclass(RemoteException.class) + .addSuperinterface(ParameterizedTypeName.get( + ClassName.get(SerializableErrorProvider.class), + errorsClassName.nestedClass(ErrorGenerationUtils.errorParametersClassName( + errorDefinition.getErrorName().getName())))) .addField(FieldSpec.builder(serializableErrorClassName, "error") .addModifiers(Modifier.PRIVATE) .build()) diff --git a/versions.lock b/versions.lock index 70fa02006..2c584e319 100644 --- a/versions.lock +++ b/versions.lock @@ -44,11 +44,11 @@ com.palantir.conjure:conjure-api-objects:4.50.0 (3 constraints: 9327531f) com.palantir.conjure:conjure-generator-common:4.50.0 (2 constraints: fd13a782) -com.palantir.conjure.java.api:errors:2.64.0 (8 constraints: a394547a) +com.palantir.conjure.java.api:errors:2.64.0-4-g1d1a7d0 (8 constraints: 42a0682a) -com.palantir.conjure.java.api:service-config:2.64.0 (6 constraints: 37668fd8) +com.palantir.conjure.java.api:service-config:2.64.0-4-g1d1a7d0 (6 constraints: ef6e261e) -com.palantir.conjure.java.api:ssl-config:2.64.0 (5 constraints: b54faa2d) +com.palantir.conjure.java.api:ssl-config:2.64.0-4-g1d1a7d0 (5 constraints: 84558bae) com.palantir.conjure.java.runtime:client-config:8.24.0 (6 constraints: ae6b4e29) @@ -60,19 +60,19 @@ com.palantir.conjure.java.runtime:keystores:8.24.0 (3 constraints: 172ac85d) com.palantir.deadlines:deadlines:0.15.0 (2 constraints: 9f1404ac) -com.palantir.dialogue:dialogue-apache-hc5-client:6.8.0-7-gde83dba (2 constraints: 6e2cef8c) +com.palantir.dialogue:dialogue-apache-hc5-client:6.8.0-22-g9d026eb (2 constraints: 3c2c49b6) -com.palantir.dialogue:dialogue-blocking-channels:6.8.0-7-gde83dba (2 constraints: 212a62b2) +com.palantir.dialogue:dialogue-blocking-channels:6.8.0-22-g9d026eb (2 constraints: bd295ee2) -com.palantir.dialogue:dialogue-clients:6.8.0-7-gde83dba (1 constraints: 63080280) +com.palantir.dialogue:dialogue-clients:6.8.0-22-g9d026eb (1 constraints: 31085185) -com.palantir.dialogue:dialogue-core:6.8.0-7-gde83dba (3 constraints: 924385ad) +com.palantir.dialogue:dialogue-core:6.8.0-22-g9d026eb (3 constraints: 2e432f0f) -com.palantir.dialogue:dialogue-futures:6.8.0-7-gde83dba (3 constraints: 3a3d7f36) +com.palantir.dialogue:dialogue-futures:6.8.0-22-g9d026eb (3 constraints: a43c338b) -com.palantir.dialogue:dialogue-serde:6.8.0-7-gde83dba (3 constraints: d034782d) +com.palantir.dialogue:dialogue-serde:6.8.0-22-g9d026eb (3 constraints: 6c34b54b) -com.palantir.dialogue:dialogue-target:6.8.0-7-gde83dba (7 constraints: c98b0624) +com.palantir.dialogue:dialogue-target:6.8.0-22-g9d026eb (7 constraints: 9d8a2158) com.palantir.goethe:goethe:0.16.0 (1 constraints: 3905353b) @@ -124,7 +124,7 @@ com.squareup:javapoet:1.13.0 (1 constraints: f50b65f7) info.picocli:picocli:4.7.7 (1 constraints: 14051b36) -io.dropwizard.metrics:metrics-core:4.2.34 (28 constraints: f8e6781b) +io.dropwizard.metrics:metrics-core:4.2.36 (28 constraints: fee68031) io.smallrye.common:smallrye-common-constraint:2.4.0 (3 constraints: c633ce60) @@ -154,7 +154,7 @@ org.apache.commons:commons-lang3:3.18.0 (3 constraints: fe2123fa) org.apache.httpcomponents.client5:httpclient5:5.4.3 (3 constraints: f43937e8) -org.apache.httpcomponents.core5:httpcore5:5.3.4 (4 constraints: 034863a7) +org.apache.httpcomponents.core5:httpcore5:5.3.5 (4 constraints: 0448f8a7) org.apache.httpcomponents.core5:httpcore5-h2:5.3.4 (1 constraints: 4013103c) @@ -238,7 +238,7 @@ com.netflix.feign:feign-jackson:8.18.0 (1 constraints: c718909e) com.palantir.conjure:conjure-core:4.50.0 (1 constraints: 3b054b3b) -com.palantir.conjure.java.api:test-utils:2.64.0 (1 constraints: 3e054f3b) +com.palantir.conjure.java.api:test-utils:2.64.0-4-g1d1a7d0 (1 constraints: 3e054f3b) com.palantir.conjure.java.runtime:conjure-java-annotations:8.24.0 (1 constraints: c418889e) diff --git a/versions.props b/versions.props index 26d5d59ae..ec7111c95 100644 --- a/versions.props +++ b/versions.props @@ -11,7 +11,7 @@ com.palantir.conjure.java.runtime:* = 8.24.0 com.palantir.conjure.verification:* = 0.19.0 com.palantir.conjure:* = 4.50.0 com.palantir.deadlines:* = 0.15.0 -com.palantir.dialogue:* = 6.8.0-7-gde83dba +com.palantir.dialogue:* = 6.8.0-22-g9d026eb com.palantir.goethe:* = 0.16.0 com.palantir.human-readable-types:* = 1.7.0 com.palantir.javapoet:javapoet = 0.7.0 From 9394834c07799f5842c9b6839e87137a557243b0 Mon Sep 17 00:00:00 2001 From: Pritham Marupaka Date: Wed, 10 Sep 2025 17:43:03 -0400 Subject: [PATCH 22/26] update dialogue version --- .../conjure/java/UndertowServiceEteTest.java | 2 +- versions.lock | 24 +++++++++---------- versions.props | 2 +- 3 files changed, 14 insertions(+), 14 deletions(-) diff --git a/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowServiceEteTest.java b/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowServiceEteTest.java index 6845be536..2f81bd972 100644 --- a/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowServiceEteTest.java +++ b/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowServiceEteTest.java @@ -588,7 +588,7 @@ public void testStringParametersDoNotChangeWhenUsingJsonAndJavaString() { // .getError() returns the SerializableError which should contain the legacy parameters sent over the wire. jsonParams = e.getError().parameters(); // e should be an instance of ErrorWithComplexArgsException, which has rich parameters as well. - // assertThat(e.getCause()).isInstanceOfSatisfying(ErrorWithComplexArgsException.class, exception + // assertThat(e).isInstanceOfSatisfying(ErrorWithComplexArgsException.class, exception // -> { // assertThat(exception.error().parameters().optionalExample().getOptionalString()) // .contains("optional-value"); diff --git a/versions.lock b/versions.lock index 2c584e319..deef6b203 100644 --- a/versions.lock +++ b/versions.lock @@ -44,11 +44,11 @@ com.palantir.conjure:conjure-api-objects:4.50.0 (3 constraints: 9327531f) com.palantir.conjure:conjure-generator-common:4.50.0 (2 constraints: fd13a782) -com.palantir.conjure.java.api:errors:2.64.0-4-g1d1a7d0 (8 constraints: 42a0682a) +com.palantir.conjure.java.api:errors:2.65.0 (8 constraints: aa94e57c) -com.palantir.conjure.java.api:service-config:2.64.0-4-g1d1a7d0 (6 constraints: ef6e261e) +com.palantir.conjure.java.api:service-config:2.65.0 (6 constraints: 3d66b5d9) -com.palantir.conjure.java.api:ssl-config:2.64.0-4-g1d1a7d0 (5 constraints: 84558bae) +com.palantir.conjure.java.api:ssl-config:2.65.0 (5 constraints: b84f512e) com.palantir.conjure.java.runtime:client-config:8.24.0 (6 constraints: ae6b4e29) @@ -60,19 +60,19 @@ com.palantir.conjure.java.runtime:keystores:8.24.0 (3 constraints: 172ac85d) com.palantir.deadlines:deadlines:0.15.0 (2 constraints: 9f1404ac) -com.palantir.dialogue:dialogue-apache-hc5-client:6.8.0-22-g9d026eb (2 constraints: 3c2c49b6) +com.palantir.dialogue:dialogue-apache-hc5-client:6.8.0-30-gc323cd4 (2 constraints: 352ca5b6) -com.palantir.dialogue:dialogue-blocking-channels:6.8.0-22-g9d026eb (2 constraints: bd295ee2) +com.palantir.dialogue:dialogue-blocking-channels:6.8.0-30-gc323cd4 (2 constraints: af2987e1) -com.palantir.dialogue:dialogue-clients:6.8.0-22-g9d026eb (1 constraints: 31085185) +com.palantir.dialogue:dialogue-clients:6.8.0-30-gc323cd4 (1 constraints: 2a08ad85) -com.palantir.dialogue:dialogue-core:6.8.0-22-g9d026eb (3 constraints: 2e432f0f) +com.palantir.dialogue:dialogue-core:6.8.0-30-gc323cd4 (3 constraints: 20434a0e) -com.palantir.dialogue:dialogue-futures:6.8.0-22-g9d026eb (3 constraints: a43c338b) +com.palantir.dialogue:dialogue-futures:6.8.0-30-gc323cd4 (3 constraints: 8f3ca187) -com.palantir.dialogue:dialogue-serde:6.8.0-22-g9d026eb (3 constraints: 6c34b54b) +com.palantir.dialogue:dialogue-serde:6.8.0-30-gc323cd4 (3 constraints: 5e34f448) -com.palantir.dialogue:dialogue-target:6.8.0-22-g9d026eb (7 constraints: 9d8a2158) +com.palantir.dialogue:dialogue-target:6.8.0-30-gc323cd4 (7 constraints: 738afb3f) com.palantir.goethe:goethe:0.16.0 (1 constraints: 3905353b) @@ -182,7 +182,7 @@ org.jboss.xnio:xnio-api:3.8.16.Final (2 constraints: d71a2474) org.jboss.xnio:xnio-nio:3.8.16.Final (1 constraints: f80dc53d) -org.jetbrains:annotations:26.0.2 (5 constraints: df499f90) +org.jetbrains:annotations:26.0.2 (4 constraints: 0a3aa099) org.jspecify:jspecify:1.0.0 (17 constraints: b80bb9e1) @@ -238,7 +238,7 @@ com.netflix.feign:feign-jackson:8.18.0 (1 constraints: c718909e) com.palantir.conjure:conjure-core:4.50.0 (1 constraints: 3b054b3b) -com.palantir.conjure.java.api:test-utils:2.64.0-4-g1d1a7d0 (1 constraints: 3e054f3b) +com.palantir.conjure.java.api:test-utils:2.65.0 (1 constraints: 3e054f3b) com.palantir.conjure.java.runtime:conjure-java-annotations:8.24.0 (1 constraints: c418889e) diff --git a/versions.props b/versions.props index ec7111c95..ed7eef086 100644 --- a/versions.props +++ b/versions.props @@ -11,7 +11,7 @@ com.palantir.conjure.java.runtime:* = 8.24.0 com.palantir.conjure.verification:* = 0.19.0 com.palantir.conjure:* = 4.50.0 com.palantir.deadlines:* = 0.15.0 -com.palantir.dialogue:* = 6.8.0-22-g9d026eb +com.palantir.dialogue:* = 6.8.0-30-gc323cd4 com.palantir.goethe:* = 0.16.0 com.palantir.human-readable-types:* = 1.7.0 com.palantir.javapoet:javapoet = 0.7.0 From c77be1f3ea3cc87b3fdef84729bcd5c1fa4008f6 Mon Sep 17 00:00:00 2001 From: Pritham Marupaka Date: Tue, 26 Aug 2025 16:55:31 -0400 Subject: [PATCH 23/26] Add tests --- .../com/palantir/another/ConjureErrors.java | 40 +++ .../com/palantir/product/ConjureErrors.java | 240 ++++++++++++++ .../palantir/product/ConjureJavaErrors.java | 40 +++ .../product/EmptyPathServiceAsync.java | 38 ++- .../product/EmptyPathServiceBlocking.java | 38 ++- .../product/EteBinaryServiceAsync.java | 119 +++++-- .../product/EteBinaryServiceBlocking.java | 113 +++++-- .../com/palantir/product/EteServiceAsync.java | 312 ++++++++++++++---- .../palantir/product/EteServiceBlocking.java | 312 ++++++++++++++---- .../dialogue/test/api/CookieServiceAsync.java | 17 +- .../test/api/CookieServiceBlocking.java | 17 +- .../conjure/java/UndertowServiceEteTest.java | 11 +- .../conjure/java/parameterized/TestCases.java | 5 +- 13 files changed, 1125 insertions(+), 177 deletions(-) diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/another/ConjureErrors.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/another/ConjureErrors.java index cdba5e331..541f49c2b 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/another/ConjureErrors.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/another/ConjureErrors.java @@ -1,9 +1,14 @@ package dialogue.com.palantir.another; +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.palantir.conjure.java.api.errors.AbstractSerializableError; import com.palantir.conjure.java.api.errors.ErrorType; import com.palantir.conjure.java.api.errors.RemoteException; +import com.palantir.conjure.java.api.errors.SerializableError; import com.palantir.conjure.java.api.errors.ServiceException; import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.Safe; import javax.annotation.Nullable; import javax.annotation.processing.Generated; @@ -39,4 +44,39 @@ public static boolean isDifferentPackageError(RemoteException remoteException) { Preconditions.checkNotNull(remoteException, "remote exception must not be null"); return DIFFERENT_PACKAGE_ERROR.name().equals(remoteException.getError().errorName()); } + + public static record DifferentPackageErrorParameters() {} + + public static final class DifferentPackageErrorSerializableError + extends AbstractSerializableError { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + DifferentPackageErrorSerializableError( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorName") @Safe String errorName, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") DifferentPackageErrorParameters parameters) { + super(errorCode, errorName, errorInstanceId, parameters); + } + + public SerializableError toSerializableError() { + return SerializableError.builder() + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()) + .build(); + } + } + + public static final class DifferentPackageErrorException extends RemoteException { + private DifferentPackageErrorSerializableError error; + + public DifferentPackageErrorException(DifferentPackageErrorSerializableError error, int status) { + super(error.toSerializableError(), status); + this.error = error; + } + + public DifferentPackageErrorSerializableError error() { + return error; + } + } } diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureErrors.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureErrors.java index b8ab5e6bf..89befeff1 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureErrors.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureErrors.java @@ -1,13 +1,18 @@ package dialogue.com.palantir.product; +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.palantir.conjure.java.api.errors.AbstractSerializableError; import com.palantir.conjure.java.api.errors.ErrorType; import com.palantir.conjure.java.api.errors.RemoteException; +import com.palantir.conjure.java.api.errors.SerializableError; import com.palantir.conjure.java.api.errors.ServiceException; import com.palantir.logsafe.Preconditions; import com.palantir.logsafe.Safe; import com.palantir.logsafe.SafeArg; import com.palantir.logsafe.Unsafe; import com.palantir.logsafe.UnsafeArg; +import java.util.Objects; import javax.annotation.Nullable; import javax.annotation.processing.Generated; @@ -324,4 +329,239 @@ public static boolean isInvalidTypeDefinition(RemoteException remoteException) { Preconditions.checkNotNull(remoteException, "remote exception must not be null"); return INVALID_TYPE_DEFINITION.name().equals(remoteException.getError().errorName()); } + + public static record ConflictingCauseSafeArgParameters( + @JsonProperty("cause") @Safe String cause, @JsonProperty("shouldThrow") @Safe boolean shouldThrow) {} + + public static record ConflictingCauseUnsafeArgParameters( + @JsonProperty("cause") @Unsafe String cause, @JsonProperty("shouldThrow") @Unsafe boolean shouldThrow) {} + + public static record ErrorWithComplexArgsParameters( + @JsonProperty("primitiveExample") @Safe PrimitiveExample primitiveExample, + @JsonProperty("collectionExample") @Safe CollectionExample collectionExample, + @JsonProperty("nestedCollectionExample") @Safe NestedCollectionExample nestedCollectionExample, + @JsonProperty("optionalExample") @Safe OptionalExample optionalExample, + @JsonProperty("objectReference") @Safe ObjectReference objectReference, + @JsonProperty("unionExample") @Safe UnionExample unionExample, + @JsonProperty("enumExample") @Safe EnumExample enumExample, + @JsonProperty("stringAlias") @Safe StringAliasEx stringAlias, + @JsonProperty("optionalAlias") @Safe OptionalAlias optionalAlias, + @JsonProperty("collectionAlias") @Safe CollectionAlias collectionAlias, + @JsonProperty("nestedAlias") @Safe NestedAlias nestedAlias, + @JsonProperty("externalExample") @Safe ExternalExample externalExample, + @JsonProperty("anyExample") @Safe AnyExample anyExample, + @JsonProperty("emptyObject") @Safe EmptyObject emptyObject, + @JsonProperty("complexExample") @Safe ComplexExample complexExample, + @JsonProperty("safetyExample") @Unsafe SafetyExample safetyExample) {} + + /** + * @param serviceName Name of the invalid service definition. + * @param serviceDef Details of the invalid service definition. + */ + public static record InvalidServiceDefinitionParameters( + @JsonProperty("serviceName") @Safe String serviceName, + @JsonProperty("serviceDef") @Unsafe Object serviceDef) {} + + public static record InvalidTypeDefinitionParameters( + @JsonProperty("typeName") @Safe String typeName, @JsonProperty("typeDef") @Unsafe Object typeDef) {} + + public static final class ConflictingCauseSafeArgSerializableError + extends AbstractSerializableError { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + ConflictingCauseSafeArgSerializableError( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorName") @Safe String errorName, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") ConflictingCauseSafeArgParameters parameters) { + super(errorCode, errorName, errorInstanceId, parameters); + } + + public SerializableError toSerializableError() { + return SerializableError.builder() + .putParameters("cause", Objects.toString(parameters().cause())) + .putParameters("shouldThrow", Objects.toString(parameters().shouldThrow())) + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()) + .build(); + } + } + + public static final class ConflictingCauseUnsafeArgSerializableError + extends AbstractSerializableError { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + ConflictingCauseUnsafeArgSerializableError( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorName") @Safe String errorName, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") ConflictingCauseUnsafeArgParameters parameters) { + super(errorCode, errorName, errorInstanceId, parameters); + } + + public SerializableError toSerializableError() { + return SerializableError.builder() + .putParameters("cause", Objects.toString(parameters().cause())) + .putParameters("shouldThrow", Objects.toString(parameters().shouldThrow())) + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()) + .build(); + } + } + + public static final class ErrorWithComplexArgsSerializableError + extends AbstractSerializableError { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + ErrorWithComplexArgsSerializableError( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorName") @Safe String errorName, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") ErrorWithComplexArgsParameters parameters) { + super(errorCode, errorName, errorInstanceId, parameters); + } + + public SerializableError toSerializableError() { + return SerializableError.builder() + .putParameters( + "primitiveExample", Objects.toString(parameters().primitiveExample())) + .putParameters( + "collectionExample", Objects.toString(parameters().collectionExample())) + .putParameters( + "nestedCollectionExample", + Objects.toString(parameters().nestedCollectionExample())) + .putParameters( + "optionalExample", Objects.toString(parameters().optionalExample())) + .putParameters( + "objectReference", Objects.toString(parameters().objectReference())) + .putParameters("unionExample", Objects.toString(parameters().unionExample())) + .putParameters("enumExample", Objects.toString(parameters().enumExample())) + .putParameters("stringAlias", Objects.toString(parameters().stringAlias())) + .putParameters( + "optionalAlias", Objects.toString(parameters().optionalAlias())) + .putParameters( + "collectionAlias", Objects.toString(parameters().collectionAlias())) + .putParameters("nestedAlias", Objects.toString(parameters().nestedAlias())) + .putParameters( + "externalExample", Objects.toString(parameters().externalExample())) + .putParameters("anyExample", Objects.toString(parameters().anyExample())) + .putParameters("emptyObject", Objects.toString(parameters().emptyObject())) + .putParameters( + "complexExample", Objects.toString(parameters().complexExample())) + .putParameters( + "safetyExample", Objects.toString(parameters().safetyExample())) + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()) + .build(); + } + } + + public static final class InvalidServiceDefinitionSerializableError + extends AbstractSerializableError { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + InvalidServiceDefinitionSerializableError( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorName") @Safe String errorName, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") InvalidServiceDefinitionParameters parameters) { + super(errorCode, errorName, errorInstanceId, parameters); + } + + public SerializableError toSerializableError() { + return SerializableError.builder() + .putParameters("serviceName", Objects.toString(parameters().serviceName())) + .putParameters("serviceDef", Objects.toString(parameters().serviceDef())) + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()) + .build(); + } + } + + public static final class InvalidTypeDefinitionSerializableError + extends AbstractSerializableError { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + InvalidTypeDefinitionSerializableError( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorName") @Safe String errorName, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") InvalidTypeDefinitionParameters parameters) { + super(errorCode, errorName, errorInstanceId, parameters); + } + + public SerializableError toSerializableError() { + return SerializableError.builder() + .putParameters("typeName", Objects.toString(parameters().typeName())) + .putParameters("typeDef", Objects.toString(parameters().typeDef())) + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()) + .build(); + } + } + + public static final class ConflictingCauseSafeArgException extends RemoteException { + private ConflictingCauseSafeArgSerializableError error; + + public ConflictingCauseSafeArgException(ConflictingCauseSafeArgSerializableError error, int status) { + super(error.toSerializableError(), status); + this.error = error; + } + + public ConflictingCauseSafeArgSerializableError error() { + return error; + } + } + + public static final class ConflictingCauseUnsafeArgException extends RemoteException { + private ConflictingCauseUnsafeArgSerializableError error; + + public ConflictingCauseUnsafeArgException(ConflictingCauseUnsafeArgSerializableError error, int status) { + super(error.toSerializableError(), status); + this.error = error; + } + + public ConflictingCauseUnsafeArgSerializableError error() { + return error; + } + } + + public static final class ErrorWithComplexArgsException extends RemoteException { + private ErrorWithComplexArgsSerializableError error; + + public ErrorWithComplexArgsException(ErrorWithComplexArgsSerializableError error, int status) { + super(error.toSerializableError(), status); + this.error = error; + } + + public ErrorWithComplexArgsSerializableError error() { + return error; + } + } + + public static final class InvalidServiceDefinitionException extends RemoteException { + private InvalidServiceDefinitionSerializableError error; + + public InvalidServiceDefinitionException(InvalidServiceDefinitionSerializableError error, int status) { + super(error.toSerializableError(), status); + this.error = error; + } + + public InvalidServiceDefinitionSerializableError error() { + return error; + } + } + + public static final class InvalidTypeDefinitionException extends RemoteException { + private InvalidTypeDefinitionSerializableError error; + + public InvalidTypeDefinitionException(InvalidTypeDefinitionSerializableError error, int status) { + super(error.toSerializableError(), status); + this.error = error; + } + + public InvalidTypeDefinitionSerializableError error() { + return error; + } + } } diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureJavaErrors.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureJavaErrors.java index def54f2f8..ff44ed2c9 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureJavaErrors.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureJavaErrors.java @@ -1,9 +1,14 @@ package dialogue.com.palantir.product; +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.palantir.conjure.java.api.errors.AbstractSerializableError; import com.palantir.conjure.java.api.errors.ErrorType; import com.palantir.conjure.java.api.errors.RemoteException; +import com.palantir.conjure.java.api.errors.SerializableError; import com.palantir.conjure.java.api.errors.ServiceException; import com.palantir.logsafe.Preconditions; +import com.palantir.logsafe.Safe; import javax.annotation.Nullable; import javax.annotation.processing.Generated; @@ -39,4 +44,39 @@ public static boolean isJavaCompilationFailed(RemoteException remoteException) { Preconditions.checkNotNull(remoteException, "remote exception must not be null"); return JAVA_COMPILATION_FAILED.name().equals(remoteException.getError().errorName()); } + + public static record JavaCompilationFailedParameters() {} + + public static final class JavaCompilationFailedSerializableError + extends AbstractSerializableError { + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + JavaCompilationFailedSerializableError( + @JsonProperty("errorCode") @Safe String errorCode, + @JsonProperty("errorName") @Safe String errorName, + @JsonProperty("errorInstanceId") @Safe String errorInstanceId, + @JsonProperty("parameters") JavaCompilationFailedParameters parameters) { + super(errorCode, errorName, errorInstanceId, parameters); + } + + public SerializableError toSerializableError() { + return SerializableError.builder() + .errorCode(errorCode()) + .errorName(errorName()) + .errorInstanceId(errorInstanceId()) + .build(); + } + } + + public static final class JavaCompilationFailedException extends RemoteException { + private JavaCompilationFailedSerializableError error; + + public JavaCompilationFailedException(JavaCompilationFailedSerializableError error, int status) { + super(error.toSerializableError(), status); + this.error = error; + } + + public JavaCompilationFailedSerializableError error() { + return error; + } + } } diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceAsync.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceAsync.java index 1cb0a894e..463bc4d1c 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceAsync.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceAsync.java @@ -10,6 +10,7 @@ import com.palantir.dialogue.Endpoint; import com.palantir.dialogue.EndpointChannel; import com.palantir.dialogue.EndpointChannelFactory; +import com.palantir.dialogue.ExceptionDeserializerArgs; import com.palantir.dialogue.PlainSerDe; import com.palantir.dialogue.Request; import com.palantir.dialogue.TypeMarker; @@ -34,11 +35,46 @@ static EmptyPathServiceAsync of(EndpointChannelFactory _endpointChannelFactory, _endpointChannelFactory.endpoint(DialogueEmptyPathEndpoints.emptyPath); private final Deserializer emptyPathDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + + private ExceptionDeserializerArgs createExceptionDeserializerArgs(TypeMarker returnType) { + return ExceptionDeserializerArgs.builder() + .returnType(returnType) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build(); + } @Override public ListenableFuture emptyPath() { Request.Builder _request = Request.builder(); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients().call(emptyPathChannel, _request.build(), emptyPathDeserializer); } diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceBlocking.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceBlocking.java index 38a0f3426..ae1deb4bc 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceBlocking.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceBlocking.java @@ -9,6 +9,7 @@ import com.palantir.dialogue.Endpoint; import com.palantir.dialogue.EndpointChannel; import com.palantir.dialogue.EndpointChannelFactory; +import com.palantir.dialogue.ExceptionDeserializerArgs; import com.palantir.dialogue.PlainSerDe; import com.palantir.dialogue.Request; import com.palantir.dialogue.TypeMarker; @@ -33,11 +34,46 @@ static EmptyPathServiceBlocking of(EndpointChannelFactory _endpointChannelFactor _endpointChannelFactory.endpoint(DialogueEmptyPathEndpoints.emptyPath); private final Deserializer emptyPathDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + + private ExceptionDeserializerArgs createExceptionDeserializerArgs(TypeMarker returnType) { + return ExceptionDeserializerArgs.builder() + .returnType(returnType) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build(); + } @Override public boolean emptyPath() { Request.Builder _request = Request.builder(); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients().callBlocking(emptyPathChannel, _request.build(), emptyPathDeserializer); } diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceAsync.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceAsync.java index 0475a8808..42823d245 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceAsync.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceAsync.java @@ -5,13 +5,16 @@ import com.palantir.dialogue.BinaryRequestBody; import com.palantir.dialogue.Channel; import com.palantir.dialogue.ConjureRuntime; +import com.palantir.dialogue.Deserializer; import com.palantir.dialogue.DialogueService; import com.palantir.dialogue.DialogueServiceFactory; import com.palantir.dialogue.Endpoint; import com.palantir.dialogue.EndpointChannel; import com.palantir.dialogue.EndpointChannelFactory; +import com.palantir.dialogue.ExceptionDeserializerArgs; import com.palantir.dialogue.PlainSerDe; import com.palantir.dialogue.Request; +import com.palantir.dialogue.TypeMarker; import com.palantir.tokens.auth.AuthHeader; import java.io.InputStream; import java.lang.Override; @@ -58,31 +61,84 @@ static EteBinaryServiceAsync of(EndpointChannelFactory _endpointChannelFactory, private final EndpointChannel postBinaryChannel = _endpointChannelFactory.endpoint(DialogueEteBinaryEndpoints.postBinary); + private final Deserializer postBinaryDeserializer = _runtime.bodySerDe() + .inputStreamDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final EndpointChannel postBinaryThrowsChannel = _endpointChannelFactory.endpoint(DialogueEteBinaryEndpoints.postBinaryThrows); + private final Deserializer postBinaryThrowsDeserializer = _runtime.bodySerDe() + .inputStreamDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final EndpointChannel getOptionalBinaryPresentChannel = _endpointChannelFactory.endpoint(DialogueEteBinaryEndpoints.getOptionalBinaryPresent); + private final Deserializer> getOptionalBinaryPresentDeserializer = + _runtime.bodySerDe() + .optionalInputStreamDeserializer( + createExceptionDeserializerArgs(new TypeMarker>() {})); + private final EndpointChannel getOptionalBinaryEmptyChannel = _endpointChannelFactory.endpoint(DialogueEteBinaryEndpoints.getOptionalBinaryEmpty); + private final Deserializer> getOptionalBinaryEmptyDeserializer = _runtime.bodySerDe() + .optionalInputStreamDeserializer( + createExceptionDeserializerArgs(new TypeMarker>() {})); + private final EndpointChannel getBinaryFailureChannel = _endpointChannelFactory.endpoint(DialogueEteBinaryEndpoints.getBinaryFailure); + private final Deserializer getBinaryFailureDeserializer = _runtime.bodySerDe() + .inputStreamDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final EndpointChannel getAliasedChannel = _endpointChannelFactory.endpoint(DialogueEteBinaryEndpoints.getAliased); + private final Deserializer> getAliasedDeserializer = _runtime.bodySerDe() + .optionalInputStreamDeserializer( + createExceptionDeserializerArgs(new TypeMarker>() {})); + + private ExceptionDeserializerArgs createExceptionDeserializerArgs(TypeMarker returnType) { + return ExceptionDeserializerArgs.builder() + .returnType(returnType) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build(); + } + @Override public ListenableFuture postBinary(AuthHeader authHeader, BinaryRequestBody body) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(_runtime.bodySerDe().serialize(body)); - return _runtime.clients() - .call( - postBinaryChannel, - _request.build(), - _runtime.bodySerDe().inputStreamDeserializer()); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } + return _runtime.clients().call(postBinaryChannel, _request.build(), postBinaryDeserializer); } @Override @@ -92,33 +148,38 @@ public ListenableFuture postBinaryThrows( _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(_runtime.bodySerDe().serialize(body)); _request.putQueryParams("bytesToRead", _plainSerDe.serializeInteger(bytesToRead)); - return _runtime.clients() - .call( - postBinaryThrowsChannel, - _request.build(), - _runtime.bodySerDe().inputStreamDeserializer()); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } + return _runtime.clients().call(postBinaryThrowsChannel, _request.build(), postBinaryThrowsDeserializer); } @Override public ListenableFuture> getOptionalBinaryPresent(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients() - .call( - getOptionalBinaryPresentChannel, - _request.build(), - _runtime.bodySerDe().optionalInputStreamDeserializer()); + .call(getOptionalBinaryPresentChannel, _request.build(), getOptionalBinaryPresentDeserializer); } @Override public ListenableFuture> getOptionalBinaryEmpty(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients() - .call( - getOptionalBinaryEmptyChannel, - _request.build(), - _runtime.bodySerDe().optionalInputStreamDeserializer()); + .call(getOptionalBinaryEmptyChannel, _request.build(), getOptionalBinaryEmptyDeserializer); } @Override @@ -128,22 +189,24 @@ public ListenableFuture getBinaryFailure( _request.putHeaderParams("Authorization", authHeader.toString()); _request.putQueryParams("numBytes", _plainSerDe.serializeInteger(numBytes)); _request.putQueryParams("useTryWithResources", _plainSerDe.serializeBoolean(useTryWithResources)); - return _runtime.clients() - .call( - getBinaryFailureChannel, - _request.build(), - _runtime.bodySerDe().inputStreamDeserializer()); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } + return _runtime.clients().call(getBinaryFailureChannel, _request.build(), getBinaryFailureDeserializer); } @Override public ListenableFuture> getAliased(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - return _runtime.clients() - .call( - getAliasedChannel, - _request.build(), - _runtime.bodySerDe().optionalInputStreamDeserializer()); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } + return _runtime.clients().call(getAliasedChannel, _request.build(), getAliasedDeserializer); } @Override diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceBlocking.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceBlocking.java index 57533e186..7ca026b1b 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceBlocking.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceBlocking.java @@ -5,13 +5,16 @@ import com.palantir.dialogue.BinaryRequestBody; import com.palantir.dialogue.Channel; import com.palantir.dialogue.ConjureRuntime; +import com.palantir.dialogue.Deserializer; import com.palantir.dialogue.DialogueService; import com.palantir.dialogue.DialogueServiceFactory; import com.palantir.dialogue.Endpoint; import com.palantir.dialogue.EndpointChannel; import com.palantir.dialogue.EndpointChannelFactory; +import com.palantir.dialogue.ExceptionDeserializerArgs; import com.palantir.dialogue.PlainSerDe; import com.palantir.dialogue.Request; +import com.palantir.dialogue.TypeMarker; import com.palantir.tokens.auth.AuthHeader; import java.io.InputStream; import java.lang.Override; @@ -61,31 +64,84 @@ static EteBinaryServiceBlocking of(EndpointChannelFactory _endpointChannelFactor private final EndpointChannel postBinaryChannel = _endpointChannelFactory.endpoint(DialogueEteBinaryEndpoints.postBinary); + private final Deserializer postBinaryDeserializer = _runtime.bodySerDe() + .inputStreamDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final EndpointChannel postBinaryThrowsChannel = _endpointChannelFactory.endpoint(DialogueEteBinaryEndpoints.postBinaryThrows); + private final Deserializer postBinaryThrowsDeserializer = _runtime.bodySerDe() + .inputStreamDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final EndpointChannel getOptionalBinaryPresentChannel = _endpointChannelFactory.endpoint(DialogueEteBinaryEndpoints.getOptionalBinaryPresent); + private final Deserializer> getOptionalBinaryPresentDeserializer = + _runtime.bodySerDe() + .optionalInputStreamDeserializer( + createExceptionDeserializerArgs(new TypeMarker>() {})); + private final EndpointChannel getOptionalBinaryEmptyChannel = _endpointChannelFactory.endpoint(DialogueEteBinaryEndpoints.getOptionalBinaryEmpty); + private final Deserializer> getOptionalBinaryEmptyDeserializer = _runtime.bodySerDe() + .optionalInputStreamDeserializer( + createExceptionDeserializerArgs(new TypeMarker>() {})); + private final EndpointChannel getBinaryFailureChannel = _endpointChannelFactory.endpoint(DialogueEteBinaryEndpoints.getBinaryFailure); + private final Deserializer getBinaryFailureDeserializer = _runtime.bodySerDe() + .inputStreamDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final EndpointChannel getAliasedChannel = _endpointChannelFactory.endpoint(DialogueEteBinaryEndpoints.getAliased); + private final Deserializer> getAliasedDeserializer = _runtime.bodySerDe() + .optionalInputStreamDeserializer( + createExceptionDeserializerArgs(new TypeMarker>() {})); + + private ExceptionDeserializerArgs createExceptionDeserializerArgs(TypeMarker returnType) { + return ExceptionDeserializerArgs.builder() + .returnType(returnType) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build(); + } + @Override public InputStream postBinary(AuthHeader authHeader, BinaryRequestBody body) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(_runtime.bodySerDe().serialize(body)); - return _runtime.clients() - .callBlocking( - postBinaryChannel, - _request.build(), - _runtime.bodySerDe().inputStreamDeserializer()); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } + return _runtime.clients().callBlocking(postBinaryChannel, _request.build(), postBinaryDeserializer); } @Override @@ -94,33 +150,43 @@ public InputStream postBinaryThrows(AuthHeader authHeader, int bytesToRead, Bina _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(_runtime.bodySerDe().serialize(body)); _request.putQueryParams("bytesToRead", _plainSerDe.serializeInteger(bytesToRead)); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients() - .callBlocking( - postBinaryThrowsChannel, - _request.build(), - _runtime.bodySerDe().inputStreamDeserializer()); + .callBlocking(postBinaryThrowsChannel, _request.build(), postBinaryThrowsDeserializer); } @Override public Optional getOptionalBinaryPresent(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients() .callBlocking( getOptionalBinaryPresentChannel, _request.build(), - _runtime.bodySerDe().optionalInputStreamDeserializer()); + getOptionalBinaryPresentDeserializer); } @Override public Optional getOptionalBinaryEmpty(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients() .callBlocking( - getOptionalBinaryEmptyChannel, - _request.build(), - _runtime.bodySerDe().optionalInputStreamDeserializer()); + getOptionalBinaryEmptyChannel, _request.build(), getOptionalBinaryEmptyDeserializer); } @Override @@ -129,22 +195,25 @@ public InputStream getBinaryFailure(AuthHeader authHeader, int numBytes, boolean _request.putHeaderParams("Authorization", authHeader.toString()); _request.putQueryParams("numBytes", _plainSerDe.serializeInteger(numBytes)); _request.putQueryParams("useTryWithResources", _plainSerDe.serializeBoolean(useTryWithResources)); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients() - .callBlocking( - getBinaryFailureChannel, - _request.build(), - _runtime.bodySerDe().inputStreamDeserializer()); + .callBlocking(getBinaryFailureChannel, _request.build(), getBinaryFailureDeserializer); } @Override public Optional getAliased(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - return _runtime.clients() - .callBlocking( - getAliasedChannel, - _request.build(), - _runtime.bodySerDe().optionalInputStreamDeserializer()); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } + return _runtime.clients().callBlocking(getAliasedChannel, _request.build(), getAliasedDeserializer); } @Override diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceAsync.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceAsync.java index 061a89312..1e35bb9cf 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceAsync.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceAsync.java @@ -11,6 +11,7 @@ import com.palantir.dialogue.Endpoint; import com.palantir.dialogue.EndpointChannel; import com.palantir.dialogue.EndpointChannelFactory; +import com.palantir.dialogue.ExceptionDeserializerArgs; import com.palantir.dialogue.PlainSerDe; import com.palantir.dialogue.Request; import com.palantir.dialogue.Serializer; @@ -219,79 +220,82 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur private final EndpointChannel stringChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.string); private final Deserializer stringDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel integerChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.integer); private final Deserializer integerDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel double_Channel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.double_); private final Deserializer double_Deserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel boolean_Channel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.boolean_); private final Deserializer boolean_Deserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel safelongChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.safelong); private final Deserializer safelongDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel ridChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.rid); - private final Deserializer ridDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer ridDeserializer = _runtime.bodySerDe() + .deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel bearertokenChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.bearertoken); - private final Deserializer bearertokenDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer bearertokenDeserializer = _runtime.bodySerDe() + .deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel optionalStringChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalString); - private final Deserializer> optionalStringDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker>() {}); + private final Deserializer> optionalStringDeserializer = _runtime.bodySerDe() + .deserializer(createExceptionDeserializerArgs(new TypeMarker>() {})); private final EndpointChannel optionalEmptyChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalEmpty); - private final Deserializer> optionalEmptyDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker>() {}); + private final Deserializer> optionalEmptyDeserializer = _runtime.bodySerDe() + .deserializer(createExceptionDeserializerArgs(new TypeMarker>() {})); private final EndpointChannel datetimeChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.datetime); - private final Deserializer datetimeDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer datetimeDeserializer = _runtime.bodySerDe() + .deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel binaryChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.binary); + private final Deserializer binaryDeserializer = _runtime.bodySerDe() + .inputStreamDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final EndpointChannel pathChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.path); private final Deserializer pathDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel externalLongPathChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.externalLongPath); private final Deserializer externalLongPathDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel optionalExternalLongQueryChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalExternalLongQuery); - private final Deserializer> optionalExternalLongQueryDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker>() {}); + private final Deserializer> optionalExternalLongQueryDeserializer = _runtime.bodySerDe() + .deserializer(createExceptionDeserializerArgs(new TypeMarker>() {})); private final Serializer notNullBodySerializer = _runtime.bodySerDe().serializer(new TypeMarker() {}); @@ -299,26 +303,26 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur private final EndpointChannel notNullBodyChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.notNullBody); - private final Deserializer notNullBodyDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer notNullBodyDeserializer = _runtime.bodySerDe() + .deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel aliasOneChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.aliasOne); - private final Deserializer aliasOneDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer aliasOneDeserializer = _runtime.bodySerDe() + .deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel optionalAliasOneChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalAliasOne); - private final Deserializer optionalAliasOneDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer optionalAliasOneDeserializer = _runtime.bodySerDe() + .deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel aliasTwoChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.aliasTwo); - private final Deserializer aliasTwoDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer aliasTwoDeserializer = _runtime.bodySerDe() + .deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final Serializer notNullBodyExternalImportSerializer = _runtime.bodySerDe() @@ -329,7 +333,8 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur private final Deserializer notNullBodyExternalImportDeserializer = _runtime.bodySerDe() - .deserializer(new TypeMarker() {}); + .deserializer(createExceptionDeserializerArgs( + new TypeMarker() {})); private final Serializer> optionalBodyExternalImportSerializer = _runtime.bodySerDe() @@ -341,70 +346,72 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur private final Deserializer> optionalBodyExternalImportDeserializer = _runtime.bodySerDe() - .deserializer( - new TypeMarker>() {}); + .deserializer(createExceptionDeserializerArgs( + new TypeMarker< + Optional>() {})); private final EndpointChannel optionalQueryExternalImportChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalQueryExternalImport); private final Deserializer> optionalQueryExternalImportDeserializer = _runtime.bodySerDe() - .deserializer( - new TypeMarker>() {}); + .deserializer(createExceptionDeserializerArgs( + new TypeMarker< + Optional>() {})); private final EndpointChannel noReturnChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.noReturn); - private final Deserializer noReturnDeserializer = - _runtime.bodySerDe().emptyBodyDeserializer(); + private final Deserializer noReturnDeserializer = _runtime.bodySerDe() + .emptyBodyDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel enumQueryChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.enumQuery); private final Deserializer enumQueryDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel enumListQueryChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.enumListQuery); - private final Deserializer> enumListQueryDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker>() {}); + private final Deserializer> enumListQueryDeserializer = _runtime.bodySerDe() + .deserializer(createExceptionDeserializerArgs(new TypeMarker>() {})); private final EndpointChannel optionalEnumQueryChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalEnumQuery); - private final Deserializer> optionalEnumQueryDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker>() {}); + private final Deserializer> optionalEnumQueryDeserializer = _runtime.bodySerDe() + .deserializer(createExceptionDeserializerArgs(new TypeMarker>() {})); private final EndpointChannel enumHeaderChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.enumHeader); private final Deserializer enumHeaderDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel jsonErrorsHeaderChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.jsonErrorsHeader); private final Deserializer jsonErrorsHeaderDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel errorParameterSerializationChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.errorParameterSerialization); private final Deserializer errorParameterSerializationDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel aliasLongEndpointChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.aliasLongEndpoint); - private final Deserializer> aliasLongEndpointDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker>() {}); + private final Deserializer> aliasLongEndpointDeserializer = _runtime.bodySerDe() + .deserializer(createExceptionDeserializerArgs(new TypeMarker>() {})); private final EndpointChannel complexQueryParametersChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.complexQueryParameters); - private final Deserializer complexQueryParametersDeserializer = - _runtime.bodySerDe().emptyBodyDeserializer(); + private final Deserializer complexQueryParametersDeserializer = _runtime.bodySerDe() + .emptyBodyDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final Serializer>> receiveListOfOptionalsSerializer = _runtime.bodySerDe().serializer(new TypeMarker>>() {}); @@ -412,8 +419,8 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur private final EndpointChannel receiveListOfOptionalsChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.receiveListOfOptionals); - private final Deserializer receiveListOfOptionalsDeserializer = - _runtime.bodySerDe().emptyBodyDeserializer(); + private final Deserializer receiveListOfOptionalsDeserializer = _runtime.bodySerDe() + .emptyBodyDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final Serializer>> receiveSetOfOptionalsSerializer = _runtime.bodySerDe().serializer(new TypeMarker>>() {}); @@ -421,8 +428,8 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur private final EndpointChannel receiveSetOfOptionalsChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.receiveSetOfOptionals); - private final Deserializer receiveSetOfOptionalsDeserializer = - _runtime.bodySerDe().emptyBodyDeserializer(); + private final Deserializer receiveSetOfOptionalsDeserializer = _runtime.bodySerDe() + .emptyBodyDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final Serializer> receiveListOfStringsSerializer = _runtime.bodySerDe().serializer(new TypeMarker>() {}); @@ -430,13 +437,48 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur private final EndpointChannel receiveListOfStringsChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.receiveListOfStrings); - private final Deserializer receiveListOfStringsDeserializer = - _runtime.bodySerDe().emptyBodyDeserializer(); + private final Deserializer receiveListOfStringsDeserializer = _runtime.bodySerDe() + .emptyBodyDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + + private ExceptionDeserializerArgs createExceptionDeserializerArgs(TypeMarker returnType) { + return ExceptionDeserializerArgs.builder() + .returnType(returnType) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build(); + } @Override public ListenableFuture string(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients().call(stringChannel, _request.build(), stringDeserializer); } @@ -444,6 +486,11 @@ public ListenableFuture string(AuthHeader authHeader) { public ListenableFuture integer(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients().call(integerChannel, _request.build(), integerDeserializer); } @@ -451,6 +498,11 @@ public ListenableFuture integer(AuthHeader authHeader) { public ListenableFuture double_(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients().call(double_Channel, _request.build(), double_Deserializer); } @@ -458,6 +510,11 @@ public ListenableFuture double_(AuthHeader authHeader) { public ListenableFuture boolean_(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients().call(boolean_Channel, _request.build(), boolean_Deserializer); } @@ -465,6 +522,11 @@ public ListenableFuture boolean_(AuthHeader authHeader) { public ListenableFuture safelong(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients().call(safelongChannel, _request.build(), safelongDeserializer); } @@ -472,6 +534,11 @@ public ListenableFuture safelong(AuthHeader authHeader) { public ListenableFuture rid(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients().call(ridChannel, _request.build(), ridDeserializer); } @@ -479,6 +546,11 @@ public ListenableFuture rid(AuthHeader authHeader) { public ListenableFuture bearertoken(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients().call(bearertokenChannel, _request.build(), bearertokenDeserializer); } @@ -486,6 +558,11 @@ public ListenableFuture bearertoken(AuthHeader authHeader) { public ListenableFuture> optionalString(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients().call(optionalStringChannel, _request.build(), optionalStringDeserializer); } @@ -493,6 +570,11 @@ public ListenableFuture> optionalString(AuthHeader authHeader) public ListenableFuture> optionalEmpty(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients().call(optionalEmptyChannel, _request.build(), optionalEmptyDeserializer); } @@ -500,6 +582,11 @@ public ListenableFuture> optionalEmpty(AuthHeader authHeader) { public ListenableFuture datetime(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients().call(datetimeChannel, _request.build(), datetimeDeserializer); } @@ -507,11 +594,12 @@ public ListenableFuture datetime(AuthHeader authHeader) { public ListenableFuture binary(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - return _runtime.clients() - .call( - binaryChannel, - _request.build(), - _runtime.bodySerDe().inputStreamDeserializer()); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } + return _runtime.clients().call(binaryChannel, _request.build(), binaryDeserializer); } @Override @@ -519,6 +607,11 @@ public ListenableFuture path(AuthHeader authHeader, String param) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("param", _plainSerDe.serializeString(param)); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients().call(pathChannel, _request.build(), pathDeserializer); } @@ -527,6 +620,11 @@ public ListenableFuture externalLongPath(AuthHeader authHeader, long param Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("param", Objects.toString(param)); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients().call(externalLongPathChannel, _request.build(), externalLongPathDeserializer); } @@ -538,6 +636,11 @@ public ListenableFuture> optionalExternalLongQuery( if (param.isPresent()) { _request.putQueryParams("param", Objects.toString(param.get())); } + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients() .call( optionalExternalLongQueryChannel, @@ -551,6 +654,11 @@ public ListenableFuture notNullBody( Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(notNullBodySerializer.serialize(notNullBody)); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients().call(notNullBodyChannel, _request.build(), notNullBodyDeserializer); } @@ -560,6 +668,11 @@ public ListenableFuture aliasOne( Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putQueryParams("queryParamName", _plainSerDe.serializeString(queryParamName.get())); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients().call(aliasOneChannel, _request.build(), aliasOneDeserializer); } @@ -573,6 +686,11 @@ public ListenableFuture optionalAliasOne( "queryParamName", _plainSerDe.serializeString(queryParamName.get().get())); } + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients().call(optionalAliasOneChannel, _request.build(), optionalAliasOneDeserializer); } @@ -584,6 +702,11 @@ public ListenableFuture aliasTwo( _request.putQueryParams( "queryParamName", _plainSerDe.serializeString(queryParamName.get().get())); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients().call(aliasTwoChannel, _request.build(), aliasTwoDeserializer); } @@ -593,6 +716,11 @@ public ListenableFuture not Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(notNullBodyExternalImportSerializer.serialize(notNullBody)); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients() .call( notNullBodyExternalImportChannel, @@ -607,6 +735,11 @@ public ListenableFuture not Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(optionalBodyExternalImportSerializer.serialize(body)); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients() .call( optionalBodyExternalImportChannel, @@ -624,6 +757,11 @@ public ListenableFuture not if (query.isPresent()) { _request.putQueryParams("query", Objects.toString(query.get())); } + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients() .call( optionalQueryExternalImportChannel, @@ -635,6 +773,11 @@ public ListenableFuture not public ListenableFuture noReturn(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients().call(noReturnChannel, _request.build(), noReturnDeserializer); } @@ -643,6 +786,11 @@ public ListenableFuture enumQuery(AuthHeader authHeader, SimpleEnum Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putQueryParams("queryParamName", Objects.toString(queryParamName)); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients().call(enumQueryChannel, _request.build(), enumQueryDeserializer); } @@ -654,6 +802,11 @@ public ListenableFuture> enumListQuery( for (SimpleEnum queryParamNameElement : queryParamName) { _request.putQueryParams("queryParamName", Objects.toString(queryParamNameElement)); } + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients().call(enumListQueryChannel, _request.build(), enumListQueryDeserializer); } @@ -665,6 +818,11 @@ public ListenableFuture> optionalEnumQuery( if (queryParamName.isPresent()) { _request.putQueryParams("queryParamName", Objects.toString(queryParamName.get())); } + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients() .call(optionalEnumQueryChannel, _request.build(), optionalEnumQueryDeserializer); } @@ -674,6 +832,11 @@ public ListenableFuture enumHeader(AuthHeader authHeader, SimpleEnum Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putHeaderParams("Custom-Header", Objects.toString(headerParameter)); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients().call(enumHeaderChannel, _request.build(), enumHeaderDeserializer); } @@ -683,6 +846,11 @@ public ListenableFuture jsonErrorsHeader(AuthHeader authHeader, String h _request.putHeaderParams("Authorization", authHeader.toString()); _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", _plainSerDe.serializeString(headerParameter)); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients().call(jsonErrorsHeaderChannel, _request.build(), jsonErrorsHeaderDeserializer); } @@ -692,6 +860,11 @@ public ListenableFuture errorParameterSerialization(AuthHeader authHeade _request.putHeaderParams("Authorization", authHeader.toString()); _request.putHeaderParams( "Accept-Conjure-Error-Parameter-Format", _plainSerDe.serializeString(headerParameter)); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients() .call( errorParameterSerializationChannel, @@ -708,6 +881,11 @@ public ListenableFuture> aliasLongEndpoint( _request.putQueryParams( "input", Objects.toString(input.get().get())); } + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients() .call(aliasLongEndpointChannel, _request.build(), aliasLongEndpointDeserializer); } @@ -731,6 +909,11 @@ public ListenableFuture complexQueryParameters( for (int intsElement : ints) { _request.putQueryParams("ints", _plainSerDe.serializeInteger(intsElement)); } + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients() .call(complexQueryParametersChannel, _request.build(), complexQueryParametersDeserializer); } @@ -740,6 +923,11 @@ public ListenableFuture receiveListOfOptionals(AuthHeader authHeader, List Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(receiveListOfOptionalsSerializer.serialize(value)); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients() .call(receiveListOfOptionalsChannel, _request.build(), receiveListOfOptionalsDeserializer); } @@ -749,6 +937,11 @@ public ListenableFuture receiveSetOfOptionals(AuthHeader authHeader, Set receiveListOfStrings(AuthHeader authHeader, List stringDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel integerChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.integer); private final Deserializer integerDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel double_Channel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.double_); private final Deserializer double_Deserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel boolean_Channel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.boolean_); private final Deserializer boolean_Deserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel safelongChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.safelong); private final Deserializer safelongDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel ridChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.rid); - private final Deserializer ridDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer ridDeserializer = _runtime.bodySerDe() + .deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel bearertokenChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.bearertoken); - private final Deserializer bearertokenDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer bearertokenDeserializer = _runtime.bodySerDe() + .deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel optionalStringChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalString); - private final Deserializer> optionalStringDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker>() {}); + private final Deserializer> optionalStringDeserializer = _runtime.bodySerDe() + .deserializer(createExceptionDeserializerArgs(new TypeMarker>() {})); private final EndpointChannel optionalEmptyChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalEmpty); - private final Deserializer> optionalEmptyDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker>() {}); + private final Deserializer> optionalEmptyDeserializer = _runtime.bodySerDe() + .deserializer(createExceptionDeserializerArgs(new TypeMarker>() {})); private final EndpointChannel datetimeChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.datetime); - private final Deserializer datetimeDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer datetimeDeserializer = _runtime.bodySerDe() + .deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel binaryChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.binary); + private final Deserializer binaryDeserializer = _runtime.bodySerDe() + .inputStreamDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + private final EndpointChannel pathChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.path); private final Deserializer pathDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel externalLongPathChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.externalLongPath); private final Deserializer externalLongPathDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel optionalExternalLongQueryChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalExternalLongQuery); - private final Deserializer> optionalExternalLongQueryDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker>() {}); + private final Deserializer> optionalExternalLongQueryDeserializer = _runtime.bodySerDe() + .deserializer(createExceptionDeserializerArgs(new TypeMarker>() {})); private final Serializer notNullBodySerializer = _runtime.bodySerDe().serializer(new TypeMarker() {}); @@ -298,26 +302,26 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con private final EndpointChannel notNullBodyChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.notNullBody); - private final Deserializer notNullBodyDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer notNullBodyDeserializer = _runtime.bodySerDe() + .deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel aliasOneChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.aliasOne); - private final Deserializer aliasOneDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer aliasOneDeserializer = _runtime.bodySerDe() + .deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel optionalAliasOneChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalAliasOne); - private final Deserializer optionalAliasOneDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer optionalAliasOneDeserializer = _runtime.bodySerDe() + .deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel aliasTwoChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.aliasTwo); - private final Deserializer aliasTwoDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + private final Deserializer aliasTwoDeserializer = _runtime.bodySerDe() + .deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final Serializer notNullBodyExternalImportSerializer = _runtime.bodySerDe() @@ -328,7 +332,8 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con private final Deserializer notNullBodyExternalImportDeserializer = _runtime.bodySerDe() - .deserializer(new TypeMarker() {}); + .deserializer(createExceptionDeserializerArgs( + new TypeMarker() {})); private final Serializer> optionalBodyExternalImportSerializer = _runtime.bodySerDe() @@ -340,70 +345,72 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con private final Deserializer> optionalBodyExternalImportDeserializer = _runtime.bodySerDe() - .deserializer( - new TypeMarker>() {}); + .deserializer(createExceptionDeserializerArgs( + new TypeMarker< + Optional>() {})); private final EndpointChannel optionalQueryExternalImportChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalQueryExternalImport); private final Deserializer> optionalQueryExternalImportDeserializer = _runtime.bodySerDe() - .deserializer( - new TypeMarker>() {}); + .deserializer(createExceptionDeserializerArgs( + new TypeMarker< + Optional>() {})); private final EndpointChannel noReturnChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.noReturn); - private final Deserializer noReturnDeserializer = - _runtime.bodySerDe().emptyBodyDeserializer(); + private final Deserializer noReturnDeserializer = _runtime.bodySerDe() + .emptyBodyDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel enumQueryChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.enumQuery); private final Deserializer enumQueryDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel enumListQueryChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.enumListQuery); - private final Deserializer> enumListQueryDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker>() {}); + private final Deserializer> enumListQueryDeserializer = _runtime.bodySerDe() + .deserializer(createExceptionDeserializerArgs(new TypeMarker>() {})); private final EndpointChannel optionalEnumQueryChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.optionalEnumQuery); - private final Deserializer> optionalEnumQueryDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker>() {}); + private final Deserializer> optionalEnumQueryDeserializer = _runtime.bodySerDe() + .deserializer(createExceptionDeserializerArgs(new TypeMarker>() {})); private final EndpointChannel enumHeaderChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.enumHeader); private final Deserializer enumHeaderDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel jsonErrorsHeaderChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.jsonErrorsHeader); private final Deserializer jsonErrorsHeaderDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel errorParameterSerializationChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.errorParameterSerialization); private final Deserializer errorParameterSerializationDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker() {}); + _runtime.bodySerDe().deserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final EndpointChannel aliasLongEndpointChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.aliasLongEndpoint); - private final Deserializer> aliasLongEndpointDeserializer = - _runtime.bodySerDe().deserializer(new TypeMarker>() {}); + private final Deserializer> aliasLongEndpointDeserializer = _runtime.bodySerDe() + .deserializer(createExceptionDeserializerArgs(new TypeMarker>() {})); private final EndpointChannel complexQueryParametersChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.complexQueryParameters); - private final Deserializer complexQueryParametersDeserializer = - _runtime.bodySerDe().emptyBodyDeserializer(); + private final Deserializer complexQueryParametersDeserializer = _runtime.bodySerDe() + .emptyBodyDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final Serializer>> receiveListOfOptionalsSerializer = _runtime.bodySerDe().serializer(new TypeMarker>>() {}); @@ -411,8 +418,8 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con private final EndpointChannel receiveListOfOptionalsChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.receiveListOfOptionals); - private final Deserializer receiveListOfOptionalsDeserializer = - _runtime.bodySerDe().emptyBodyDeserializer(); + private final Deserializer receiveListOfOptionalsDeserializer = _runtime.bodySerDe() + .emptyBodyDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final Serializer>> receiveSetOfOptionalsSerializer = _runtime.bodySerDe().serializer(new TypeMarker>>() {}); @@ -420,8 +427,8 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con private final EndpointChannel receiveSetOfOptionalsChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.receiveSetOfOptionals); - private final Deserializer receiveSetOfOptionalsDeserializer = - _runtime.bodySerDe().emptyBodyDeserializer(); + private final Deserializer receiveSetOfOptionalsDeserializer = _runtime.bodySerDe() + .emptyBodyDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); private final Serializer> receiveListOfStringsSerializer = _runtime.bodySerDe().serializer(new TypeMarker>() {}); @@ -429,13 +436,48 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con private final EndpointChannel receiveListOfStringsChannel = _endpointChannelFactory.endpoint(DialogueEteEndpoints.receiveListOfStrings); - private final Deserializer receiveListOfStringsDeserializer = - _runtime.bodySerDe().emptyBodyDeserializer(); + private final Deserializer receiveListOfStringsDeserializer = _runtime.bodySerDe() + .emptyBodyDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + + private ExceptionDeserializerArgs createExceptionDeserializerArgs(TypeMarker returnType) { + return ExceptionDeserializerArgs.builder() + .returnType(returnType) + .exception( + ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .build(); + } @Override public String string(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients().callBlocking(stringChannel, _request.build(), stringDeserializer); } @@ -443,6 +485,11 @@ public String string(AuthHeader authHeader) { public int integer(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients().callBlocking(integerChannel, _request.build(), integerDeserializer); } @@ -450,6 +497,11 @@ public int integer(AuthHeader authHeader) { public double double_(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients().callBlocking(double_Channel, _request.build(), double_Deserializer); } @@ -457,6 +509,11 @@ public double double_(AuthHeader authHeader) { public boolean boolean_(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients().callBlocking(boolean_Channel, _request.build(), boolean_Deserializer); } @@ -464,6 +521,11 @@ public boolean boolean_(AuthHeader authHeader) { public SafeLong safelong(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients().callBlocking(safelongChannel, _request.build(), safelongDeserializer); } @@ -471,6 +533,11 @@ public SafeLong safelong(AuthHeader authHeader) { public ResourceIdentifier rid(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients().callBlocking(ridChannel, _request.build(), ridDeserializer); } @@ -478,6 +545,11 @@ public ResourceIdentifier rid(AuthHeader authHeader) { public BearerToken bearertoken(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients().callBlocking(bearertokenChannel, _request.build(), bearertokenDeserializer); } @@ -485,6 +557,11 @@ public BearerToken bearertoken(AuthHeader authHeader) { public Optional optionalString(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients() .callBlocking(optionalStringChannel, _request.build(), optionalStringDeserializer); } @@ -493,6 +570,11 @@ public Optional optionalString(AuthHeader authHeader) { public Optional optionalEmpty(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients() .callBlocking(optionalEmptyChannel, _request.build(), optionalEmptyDeserializer); } @@ -501,6 +583,11 @@ public Optional optionalEmpty(AuthHeader authHeader) { public OffsetDateTime datetime(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients().callBlocking(datetimeChannel, _request.build(), datetimeDeserializer); } @@ -508,11 +595,12 @@ public OffsetDateTime datetime(AuthHeader authHeader) { public InputStream binary(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); - return _runtime.clients() - .callBlocking( - binaryChannel, - _request.build(), - _runtime.bodySerDe().inputStreamDeserializer()); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } + return _runtime.clients().callBlocking(binaryChannel, _request.build(), binaryDeserializer); } @Override @@ -520,6 +608,11 @@ public String path(AuthHeader authHeader, String param) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("param", _plainSerDe.serializeString(param)); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients().callBlocking(pathChannel, _request.build(), pathDeserializer); } @@ -528,6 +621,11 @@ public long externalLongPath(AuthHeader authHeader, long param) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putPathParams("param", Objects.toString(param)); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients() .callBlocking(externalLongPathChannel, _request.build(), externalLongPathDeserializer); } @@ -539,6 +637,11 @@ public Optional optionalExternalLongQuery(AuthHeader authHeader, Optional< if (param.isPresent()) { _request.putQueryParams("param", Objects.toString(param.get())); } + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients() .callBlocking( optionalExternalLongQueryChannel, @@ -551,6 +654,11 @@ public StringAliasExample notNullBody(AuthHeader authHeader, StringAliasExample Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(notNullBodySerializer.serialize(notNullBody)); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients().callBlocking(notNullBodyChannel, _request.build(), notNullBodyDeserializer); } @@ -559,6 +667,11 @@ public StringAliasExample aliasOne(AuthHeader authHeader, StringAliasExample que Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putQueryParams("queryParamName", _plainSerDe.serializeString(queryParamName.get())); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients().callBlocking(aliasOneChannel, _request.build(), aliasOneDeserializer); } @@ -572,6 +685,11 @@ public StringAliasExample optionalAliasOne( "queryParamName", _plainSerDe.serializeString(queryParamName.get().get())); } + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients() .callBlocking(optionalAliasOneChannel, _request.build(), optionalAliasOneDeserializer); } @@ -583,6 +701,11 @@ public NestedStringAliasExample aliasTwo(AuthHeader authHeader, NestedStringAlia _request.putQueryParams( "queryParamName", _plainSerDe.serializeString(queryParamName.get().get())); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients().callBlocking(aliasTwoChannel, _request.build(), aliasTwoDeserializer); } @@ -592,6 +715,11 @@ public allexamples.com.palantir.product.StringAliasExample notNullBodyExternalIm Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(notNullBodyExternalImportSerializer.serialize(notNullBody)); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients() .callBlocking( notNullBodyExternalImportChannel, @@ -605,6 +733,11 @@ public Optional optionalBod Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(optionalBodyExternalImportSerializer.serialize(body)); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients() .callBlocking( optionalBodyExternalImportChannel, @@ -620,6 +753,11 @@ public Optional optionalQue if (query.isPresent()) { _request.putQueryParams("query", Objects.toString(query.get())); } + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients() .callBlocking( optionalQueryExternalImportChannel, @@ -631,6 +769,11 @@ public Optional optionalQue public void noReturn(AuthHeader authHeader) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } _runtime.clients().callBlocking(noReturnChannel, _request.build(), noReturnDeserializer); } @@ -639,6 +782,11 @@ public SimpleEnum enumQuery(AuthHeader authHeader, SimpleEnum queryParamName) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.putQueryParams("queryParamName", Objects.toString(queryParamName)); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients().callBlocking(enumQueryChannel, _request.build(), enumQueryDeserializer); } @@ -649,6 +797,11 @@ public List enumListQuery(AuthHeader authHeader, List qu for (SimpleEnum queryParamNameElement : queryParamName) { _request.putQueryParams("queryParamName", Objects.toString(queryParamNameElement)); } + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients() .callBlocking(enumListQueryChannel, _request.build(), enumListQueryDeserializer); } @@ -660,6 +813,11 @@ public Optional optionalEnumQuery(AuthHeader authHeader, Optional aliasLongEndpoint(AuthHeader authHeader, Optional> Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(receiveListOfOptionalsSerializer.serialize(value)); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } _runtime.clients() .callBlocking( receiveListOfOptionalsChannel, _request.build(), receiveListOfOptionalsDeserializer); @@ -746,6 +934,11 @@ public void receiveSetOfOptionals(AuthHeader authHeader, Set> v Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(receiveSetOfOptionalsSerializer.serialize(value)); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } _runtime.clients() .callBlocking( receiveSetOfOptionalsChannel, _request.build(), receiveSetOfOptionalsDeserializer); @@ -756,6 +949,11 @@ public void receiveListOfStrings(AuthHeader authHeader, List value) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Authorization", authHeader.toString()); _request.body(receiveListOfStringsSerializer.serialize(value)); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } _runtime.clients() .callBlocking(receiveListOfStringsChannel, _request.build(), receiveListOfStringsDeserializer); } diff --git a/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceAsync.java b/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceAsync.java index 835e97b78..8e3b7ca3c 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceAsync.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceAsync.java @@ -10,8 +10,10 @@ import com.palantir.dialogue.Endpoint; import com.palantir.dialogue.EndpointChannel; import com.palantir.dialogue.EndpointChannelFactory; +import com.palantir.dialogue.ExceptionDeserializerArgs; import com.palantir.dialogue.PlainSerDe; import com.palantir.dialogue.Request; +import com.palantir.dialogue.TypeMarker; import com.palantir.tokens.auth.BearerToken; import java.lang.Override; import java.lang.String; @@ -33,13 +35,24 @@ static CookieServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Con private final EndpointChannel eatCookiesChannel = _endpointChannelFactory.endpoint(DialogueCookieEndpoints.eatCookies); - private final Deserializer eatCookiesDeserializer = - _runtime.bodySerDe().emptyBodyDeserializer(); + private final Deserializer eatCookiesDeserializer = _runtime.bodySerDe() + .emptyBodyDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + + private ExceptionDeserializerArgs createExceptionDeserializerArgs(TypeMarker returnType) { + return ExceptionDeserializerArgs.builder() + .returnType(returnType) + .build(); + } @Override public ListenableFuture eatCookies(BearerToken token) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Cookie", "PALANTIR_TOKEN=" + _plainSerDe.serializeBearerToken(token)); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } return _runtime.clients().call(eatCookiesChannel, _request.build(), eatCookiesDeserializer); } diff --git a/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceBlocking.java b/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceBlocking.java index 78e6e8cc0..6411b609a 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceBlocking.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceBlocking.java @@ -9,8 +9,10 @@ import com.palantir.dialogue.Endpoint; import com.palantir.dialogue.EndpointChannel; import com.palantir.dialogue.EndpointChannelFactory; +import com.palantir.dialogue.ExceptionDeserializerArgs; import com.palantir.dialogue.PlainSerDe; import com.palantir.dialogue.Request; +import com.palantir.dialogue.TypeMarker; import com.palantir.tokens.auth.BearerToken; import java.lang.Override; import java.lang.String; @@ -32,13 +34,24 @@ static CookieServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, private final EndpointChannel eatCookiesChannel = _endpointChannelFactory.endpoint(DialogueCookieEndpoints.eatCookies); - private final Deserializer eatCookiesDeserializer = - _runtime.bodySerDe().emptyBodyDeserializer(); + private final Deserializer eatCookiesDeserializer = _runtime.bodySerDe() + .emptyBodyDeserializer(createExceptionDeserializerArgs(new TypeMarker() {})); + + private ExceptionDeserializerArgs createExceptionDeserializerArgs(TypeMarker returnType) { + return ExceptionDeserializerArgs.builder() + .returnType(returnType) + .build(); + } @Override public void eatCookies(BearerToken token) { Request.Builder _request = Request.builder(); _request.putHeaderParams("Cookie", "PALANTIR_TOKEN=" + _plainSerDe.serializeBearerToken(token)); + if (_runtime.bodySerDe().errorParameterFormat().isPresent()) { + _request.putHeaderParams( + "Accept-Conjure-Error-Parameter-Format", + _runtime.bodySerDe().errorParameterFormat().get().toString()); + } _runtime.clients().callBlocking(eatCookiesChannel, _request.build(), eatCookiesDeserializer); } diff --git a/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowServiceEteTest.java b/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowServiceEteTest.java index 2f81bd972..02b6c96ae 100644 --- a/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowServiceEteTest.java +++ b/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowServiceEteTest.java @@ -587,12 +587,11 @@ public void testStringParametersDoNotChangeWhenUsingJsonAndJavaString() { } catch (RemoteException e) { // .getError() returns the SerializableError which should contain the legacy parameters sent over the wire. jsonParams = e.getError().parameters(); - // e should be an instance of ErrorWithComplexArgsException, which has rich parameters as well. - // assertThat(e).isInstanceOfSatisfying(ErrorWithComplexArgsException.class, exception - // -> { - // assertThat(exception.error().parameters().optionalExample().getOptionalString()) - // .contains("optional-value"); - // }); + // e should be an instance of ErrorWithComplexArgsException, which has rich parameters as well + assertThat(e).isInstanceOfSatisfying(ErrorWithComplexArgsException.class, exception -> { + assertThat(exception.error().parameters().optionalExample().getOptionalString()) + .contains("optional-value"); + }); } // Assert that the two maps contain the same keys and values, except for the `primitiveExample` and `anyExample` diff --git a/conjure-java-core/src/test/java/com/palantir/conjure/java/parameterized/TestCases.java b/conjure-java-core/src/test/java/com/palantir/conjure/java/parameterized/TestCases.java index ee8f89eb8..b6600982f 100644 --- a/conjure-java-core/src/test/java/com/palantir/conjure/java/parameterized/TestCases.java +++ b/conjure-java-core/src/test/java/com/palantir/conjure/java/parameterized/TestCases.java @@ -176,7 +176,10 @@ public final class TestCases { .files(Path.of("ete-service.yml")) .files(Path.of("ete-binary.yml")) .files(Path.of("example-errors.yml")) - .options(Options.builder().apiVersion("1.2.3").build()) + .options(Options.builder() + .apiVersion("1.2.3") + .generateErrorParameterFormatRespectingDialogueInterfaces(true) + .build()) .generatorTypes(List.of(GeneratorType.DIALOGUE, GeneratorType.OBJECT, GeneratorType.ERROR)) .build()) .add(ParameterizedTestCase.builder() From 5d2e2825d0a05adbebb624b75c79514ec00a10db Mon Sep 17 00:00:00 2001 From: Pritham Marupaka Date: Thu, 28 Aug 2025 17:18:36 -0400 Subject: [PATCH 24/26] review changes --- .../product/EmptyPathServiceAsync.java | 8 +++ .../product/EmptyPathServiceBlocking.java | 8 +++ .../product/EteBinaryServiceAsync.java | 8 +++ .../product/EteBinaryServiceBlocking.java | 8 +++ .../com/palantir/product/EteServiceAsync.java | 8 +++ .../palantir/product/EteServiceBlocking.java | 8 +++ .../dialogue/test/api/CookieServiceAsync.java | 49 +++++++++++++++++++ .../test/api/CookieServiceBlocking.java | 49 +++++++++++++++++++ 8 files changed, 146 insertions(+) diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceAsync.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceAsync.java index 463bc4d1c..002e9256c 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceAsync.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceAsync.java @@ -40,6 +40,14 @@ static EmptyPathServiceAsync of(EndpointChannelFactory _endpointChannelFactory, private ExceptionDeserializerArgs createExceptionDeserializerArgs(TypeMarker returnType) { return ExceptionDeserializerArgs.builder() .returnType(returnType) + .exception( + dialogue.com.palantir.another.ConjureErrors.DIFFERENT_PACKAGE_ERROR.name(), + new TypeMarker< + dialogue.com.palantir.another.ConjureErrors + .DifferentPackageErrorSerializableError>() {}, + new TypeMarker< + dialogue.com.palantir.another.ConjureErrors + .DifferentPackageErrorException>() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceBlocking.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceBlocking.java index ae1deb4bc..e0e4a8fe1 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceBlocking.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EmptyPathServiceBlocking.java @@ -39,6 +39,14 @@ static EmptyPathServiceBlocking of(EndpointChannelFactory _endpointChannelFactor private ExceptionDeserializerArgs createExceptionDeserializerArgs(TypeMarker returnType) { return ExceptionDeserializerArgs.builder() .returnType(returnType) + .exception( + dialogue.com.palantir.another.ConjureErrors.DIFFERENT_PACKAGE_ERROR.name(), + new TypeMarker< + dialogue.com.palantir.another.ConjureErrors + .DifferentPackageErrorSerializableError>() {}, + new TypeMarker< + dialogue.com.palantir.another.ConjureErrors + .DifferentPackageErrorException>() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceAsync.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceAsync.java index 42823d245..fcb70a714 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceAsync.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceAsync.java @@ -101,6 +101,14 @@ static EteBinaryServiceAsync of(EndpointChannelFactory _endpointChannelFactory, private ExceptionDeserializerArgs createExceptionDeserializerArgs(TypeMarker returnType) { return ExceptionDeserializerArgs.builder() .returnType(returnType) + .exception( + dialogue.com.palantir.another.ConjureErrors.DIFFERENT_PACKAGE_ERROR.name(), + new TypeMarker< + dialogue.com.palantir.another.ConjureErrors + .DifferentPackageErrorSerializableError>() {}, + new TypeMarker< + dialogue.com.palantir.another.ConjureErrors + .DifferentPackageErrorException>() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceBlocking.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceBlocking.java index 7ca026b1b..2141a81c6 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceBlocking.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteBinaryServiceBlocking.java @@ -104,6 +104,14 @@ static EteBinaryServiceBlocking of(EndpointChannelFactory _endpointChannelFactor private ExceptionDeserializerArgs createExceptionDeserializerArgs(TypeMarker returnType) { return ExceptionDeserializerArgs.builder() .returnType(returnType) + .exception( + dialogue.com.palantir.another.ConjureErrors.DIFFERENT_PACKAGE_ERROR.name(), + new TypeMarker< + dialogue.com.palantir.another.ConjureErrors + .DifferentPackageErrorSerializableError>() {}, + new TypeMarker< + dialogue.com.palantir.another.ConjureErrors + .DifferentPackageErrorException>() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceAsync.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceAsync.java index 1e35bb9cf..d5f200c9f 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceAsync.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceAsync.java @@ -443,6 +443,14 @@ static EteServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Conjur private ExceptionDeserializerArgs createExceptionDeserializerArgs(TypeMarker returnType) { return ExceptionDeserializerArgs.builder() .returnType(returnType) + .exception( + dialogue.com.palantir.another.ConjureErrors.DIFFERENT_PACKAGE_ERROR.name(), + new TypeMarker< + dialogue.com.palantir.another.ConjureErrors + .DifferentPackageErrorSerializableError>() {}, + new TypeMarker< + dialogue.com.palantir.another.ConjureErrors + .DifferentPackageErrorException>() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceBlocking.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceBlocking.java index 8d71acc1c..9b8a1dcfc 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceBlocking.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/EteServiceBlocking.java @@ -442,6 +442,14 @@ static EteServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, Con private ExceptionDeserializerArgs createExceptionDeserializerArgs(TypeMarker returnType) { return ExceptionDeserializerArgs.builder() .returnType(returnType) + .exception( + dialogue.com.palantir.another.ConjureErrors.DIFFERENT_PACKAGE_ERROR.name(), + new TypeMarker< + dialogue.com.palantir.another.ConjureErrors + .DifferentPackageErrorSerializableError>() {}, + new TypeMarker< + dialogue.com.palantir.another.ConjureErrors + .DifferentPackageErrorException>() {}) .exception( ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), new TypeMarker() {}, diff --git a/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceAsync.java b/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceAsync.java index 8e3b7ca3c..7831a6f68 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceAsync.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceAsync.java @@ -15,6 +15,8 @@ import com.palantir.dialogue.Request; import com.palantir.dialogue.TypeMarker; import com.palantir.tokens.auth.BearerToken; +import dialogue.com.palantir.another.ConjureErrors; +import dialogue.com.palantir.product.ConjureJavaErrors; import java.lang.Override; import java.lang.String; import java.lang.Void; @@ -41,6 +43,53 @@ static CookieServiceAsync of(EndpointChannelFactory _endpointChannelFactory, Con private ExceptionDeserializerArgs createExceptionDeserializerArgs(TypeMarker returnType) { return ExceptionDeserializerArgs.builder() .returnType(returnType) + .exception( + ConjureErrors.DIFFERENT_PACKAGE_ERROR.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + dialogue.com.palantir.product.ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker< + dialogue.com.palantir.product.ConjureErrors + .ConflictingCauseSafeArgSerializableError>() {}, + new TypeMarker< + dialogue.com.palantir.product.ConjureErrors + .ConflictingCauseSafeArgException>() {}) + .exception( + dialogue.com.palantir.product.ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker< + dialogue.com.palantir.product.ConjureErrors + .ConflictingCauseUnsafeArgSerializableError>() {}, + new TypeMarker< + dialogue.com.palantir.product.ConjureErrors + .ConflictingCauseUnsafeArgException>() {}) + .exception( + dialogue.com.palantir.product.ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker< + dialogue.com.palantir.product.ConjureErrors + .ErrorWithComplexArgsSerializableError>() {}, + new TypeMarker< + dialogue.com.palantir.product.ConjureErrors.ErrorWithComplexArgsException>() {}) + .exception( + dialogue.com.palantir.product.ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker< + dialogue.com.palantir.product.ConjureErrors + .InvalidServiceDefinitionSerializableError>() {}, + new TypeMarker< + dialogue.com.palantir.product.ConjureErrors + .InvalidServiceDefinitionException>() {}) + .exception( + dialogue.com.palantir.product.ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker< + dialogue.com.palantir.product.ConjureErrors + .InvalidTypeDefinitionSerializableError>() {}, + new TypeMarker< + dialogue.com.palantir.product.ConjureErrors + .InvalidTypeDefinitionException>() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) .build(); } diff --git a/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceBlocking.java b/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceBlocking.java index 6411b609a..4b06d95d1 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceBlocking.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/test/api/CookieServiceBlocking.java @@ -14,6 +14,8 @@ import com.palantir.dialogue.Request; import com.palantir.dialogue.TypeMarker; import com.palantir.tokens.auth.BearerToken; +import dialogue.com.palantir.another.ConjureErrors; +import dialogue.com.palantir.product.ConjureJavaErrors; import java.lang.Override; import java.lang.String; import java.lang.Void; @@ -40,6 +42,53 @@ static CookieServiceBlocking of(EndpointChannelFactory _endpointChannelFactory, private ExceptionDeserializerArgs createExceptionDeserializerArgs(TypeMarker returnType) { return ExceptionDeserializerArgs.builder() .returnType(returnType) + .exception( + ConjureErrors.DIFFERENT_PACKAGE_ERROR.name(), + new TypeMarker() {}, + new TypeMarker() {}) + .exception( + dialogue.com.palantir.product.ConjureErrors.CONFLICTING_CAUSE_SAFE_ARG.name(), + new TypeMarker< + dialogue.com.palantir.product.ConjureErrors + .ConflictingCauseSafeArgSerializableError>() {}, + new TypeMarker< + dialogue.com.palantir.product.ConjureErrors + .ConflictingCauseSafeArgException>() {}) + .exception( + dialogue.com.palantir.product.ConjureErrors.CONFLICTING_CAUSE_UNSAFE_ARG.name(), + new TypeMarker< + dialogue.com.palantir.product.ConjureErrors + .ConflictingCauseUnsafeArgSerializableError>() {}, + new TypeMarker< + dialogue.com.palantir.product.ConjureErrors + .ConflictingCauseUnsafeArgException>() {}) + .exception( + dialogue.com.palantir.product.ConjureErrors.ERROR_WITH_COMPLEX_ARGS.name(), + new TypeMarker< + dialogue.com.palantir.product.ConjureErrors + .ErrorWithComplexArgsSerializableError>() {}, + new TypeMarker< + dialogue.com.palantir.product.ConjureErrors.ErrorWithComplexArgsException>() {}) + .exception( + dialogue.com.palantir.product.ConjureErrors.INVALID_SERVICE_DEFINITION.name(), + new TypeMarker< + dialogue.com.palantir.product.ConjureErrors + .InvalidServiceDefinitionSerializableError>() {}, + new TypeMarker< + dialogue.com.palantir.product.ConjureErrors + .InvalidServiceDefinitionException>() {}) + .exception( + dialogue.com.palantir.product.ConjureErrors.INVALID_TYPE_DEFINITION.name(), + new TypeMarker< + dialogue.com.palantir.product.ConjureErrors + .InvalidTypeDefinitionSerializableError>() {}, + new TypeMarker< + dialogue.com.palantir.product.ConjureErrors + .InvalidTypeDefinitionException>() {}) + .exception( + ConjureJavaErrors.JAVA_COMPILATION_FAILED.name(), + new TypeMarker() {}, + new TypeMarker() {}) .build(); } From 377e1855ba38ca3742e4a81689c053bf40077ce8 Mon Sep 17 00:00:00 2001 From: Pritham Marupaka Date: Sun, 7 Sep 2025 19:26:24 -0400 Subject: [PATCH 25/26] Use SerializableErrorProvider --- .../com/palantir/another/ConjureErrors.java | 4 +++- .../com/palantir/product/ConjureErrors.java | 16 +++++++++++----- .../com/palantir/product/ConjureJavaErrors.java | 4 +++- 3 files changed, 17 insertions(+), 7 deletions(-) diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/another/ConjureErrors.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/another/ConjureErrors.java index 541f49c2b..6b16ea9cb 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/another/ConjureErrors.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/another/ConjureErrors.java @@ -6,6 +6,7 @@ import com.palantir.conjure.java.api.errors.ErrorType; import com.palantir.conjure.java.api.errors.RemoteException; import com.palantir.conjure.java.api.errors.SerializableError; +import com.palantir.conjure.java.api.errors.SerializableErrorProvider; import com.palantir.conjure.java.api.errors.ServiceException; import com.palantir.logsafe.Preconditions; import com.palantir.logsafe.Safe; @@ -67,7 +68,8 @@ public SerializableError toSerializableError() { } } - public static final class DifferentPackageErrorException extends RemoteException { + public static final class DifferentPackageErrorException extends RemoteException + implements SerializableErrorProvider { private DifferentPackageErrorSerializableError error; public DifferentPackageErrorException(DifferentPackageErrorSerializableError error, int status) { diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureErrors.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureErrors.java index 89befeff1..1fc713c93 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureErrors.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureErrors.java @@ -6,6 +6,7 @@ import com.palantir.conjure.java.api.errors.ErrorType; import com.palantir.conjure.java.api.errors.RemoteException; import com.palantir.conjure.java.api.errors.SerializableError; +import com.palantir.conjure.java.api.errors.SerializableErrorProvider; import com.palantir.conjure.java.api.errors.ServiceException; import com.palantir.logsafe.Preconditions; import com.palantir.logsafe.Safe; @@ -500,7 +501,8 @@ public SerializableError toSerializableError() { } } - public static final class ConflictingCauseSafeArgException extends RemoteException { + public static final class ConflictingCauseSafeArgException extends RemoteException + implements SerializableErrorProvider { private ConflictingCauseSafeArgSerializableError error; public ConflictingCauseSafeArgException(ConflictingCauseSafeArgSerializableError error, int status) { @@ -513,7 +515,8 @@ public ConflictingCauseSafeArgSerializableError error() { } } - public static final class ConflictingCauseUnsafeArgException extends RemoteException { + public static final class ConflictingCauseUnsafeArgException extends RemoteException + implements SerializableErrorProvider { private ConflictingCauseUnsafeArgSerializableError error; public ConflictingCauseUnsafeArgException(ConflictingCauseUnsafeArgSerializableError error, int status) { @@ -526,7 +529,8 @@ public ConflictingCauseUnsafeArgSerializableError error() { } } - public static final class ErrorWithComplexArgsException extends RemoteException { + public static final class ErrorWithComplexArgsException extends RemoteException + implements SerializableErrorProvider { private ErrorWithComplexArgsSerializableError error; public ErrorWithComplexArgsException(ErrorWithComplexArgsSerializableError error, int status) { @@ -539,7 +543,8 @@ public ErrorWithComplexArgsSerializableError error() { } } - public static final class InvalidServiceDefinitionException extends RemoteException { + public static final class InvalidServiceDefinitionException extends RemoteException + implements SerializableErrorProvider { private InvalidServiceDefinitionSerializableError error; public InvalidServiceDefinitionException(InvalidServiceDefinitionSerializableError error, int status) { @@ -552,7 +557,8 @@ public InvalidServiceDefinitionSerializableError error() { } } - public static final class InvalidTypeDefinitionException extends RemoteException { + public static final class InvalidTypeDefinitionException extends RemoteException + implements SerializableErrorProvider { private InvalidTypeDefinitionSerializableError error; public InvalidTypeDefinitionException(InvalidTypeDefinitionSerializableError error, int status) { diff --git a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureJavaErrors.java b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureJavaErrors.java index ff44ed2c9..f437f45e0 100644 --- a/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureJavaErrors.java +++ b/conjure-java-core/src/integrationInput/java/dialogue/com/palantir/product/ConjureJavaErrors.java @@ -6,6 +6,7 @@ import com.palantir.conjure.java.api.errors.ErrorType; import com.palantir.conjure.java.api.errors.RemoteException; import com.palantir.conjure.java.api.errors.SerializableError; +import com.palantir.conjure.java.api.errors.SerializableErrorProvider; import com.palantir.conjure.java.api.errors.ServiceException; import com.palantir.logsafe.Preconditions; import com.palantir.logsafe.Safe; @@ -67,7 +68,8 @@ public SerializableError toSerializableError() { } } - public static final class JavaCompilationFailedException extends RemoteException { + public static final class JavaCompilationFailedException extends RemoteException + implements SerializableErrorProvider { private JavaCompilationFailedSerializableError error; public JavaCompilationFailedException(JavaCompilationFailedSerializableError error, int status) { From 948b05d0aa5fe7f289950bd6562165d8a1adcc0a Mon Sep 17 00:00:00 2001 From: Pritham Marupaka Date: Wed, 10 Sep 2025 17:46:51 -0400 Subject: [PATCH 26/26] update test --- .../java/com/palantir/conjure/java/UndertowServiceEteTest.java | 1 + 1 file changed, 1 insertion(+) diff --git a/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowServiceEteTest.java b/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowServiceEteTest.java index 02b6c96ae..3e1d70147 100644 --- a/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowServiceEteTest.java +++ b/conjure-java-core/src/test/java/com/palantir/conjure/java/UndertowServiceEteTest.java @@ -37,6 +37,7 @@ import com.palantir.dialogue.clients.DialogueClients; import com.palantir.ri.ResourceIdentifier; import com.palantir.tokens.auth.AuthHeader; +import dialogue.com.palantir.product.ConjureErrors.ErrorWithComplexArgsException; import dialogue.com.palantir.product.EteBinaryServiceBlocking; import dialogue.com.palantir.product.EteServiceAsync; import dialogue.com.palantir.product.EteServiceBlocking;