ClientOptions.java

/**
 * This file was auto-generated by Fern from our API Definition.
 */
package com.cloudpdf.api.core;

import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.TimeUnit;
import java.util.function.Supplier;
import okhttp3.OkHttpClient;

public final class ClientOptions {
    private final Environment environment;

    private final Map<String, String> headers;

    private final Map<String, Supplier<String>> headerSuppliers;

    private final OkHttpClient httpClient;

    private final int timeout;

    private final int maxRetries;

    private final Optional<Long> initialRetryDelayMillis;

    private final Optional<Long> maxRetryDelayMillis;

    private final Optional<Double> retryJitterFactor;

    private final Optional<LogConfig> logging;

    private ClientOptions(
            Environment environment,
            Map<String, String> headers,
            Map<String, Supplier<String>> headerSuppliers,
            OkHttpClient httpClient,
            int timeout,
            int maxRetries,
            Optional<Long> initialRetryDelayMillis,
            Optional<Long> maxRetryDelayMillis,
            Optional<Double> retryJitterFactor,
            Optional<LogConfig> logging) {
        this.environment = environment;
        this.headers = new HashMap<>();
        this.headers.putAll(headers);
        this.headers.putAll(new HashMap<String, String>() {
            {
                put("X-Fern-Language", "JAVA");
                put("X-Fern-SDK-Name", "com.cloudpdf:sdk");
                put("X-Fern-SDK-Version", "3.0.0-alpha.11");
            }
        });
        this.headerSuppliers = headerSuppliers;
        this.httpClient = httpClient;
        this.timeout = timeout;
        this.maxRetries = maxRetries;
        this.initialRetryDelayMillis = initialRetryDelayMillis;
        this.maxRetryDelayMillis = maxRetryDelayMillis;
        this.retryJitterFactor = retryJitterFactor;
        this.logging = logging;
    }

    public Environment environment() {
        return this.environment;
    }

    public Map<String, String> headers(RequestOptions requestOptions) {
        Map<String, String> values = new HashMap<>(this.headers);
        headerSuppliers.forEach((key, supplier) -> {
            values.put(key, supplier.get());
        });
        if (requestOptions != null) {
            values.putAll(requestOptions.getHeaders());
        }
        return values;
    }

    public int timeout(RequestOptions requestOptions) {
        if (requestOptions == null) {
            return this.timeout;
        }
        return requestOptions.getTimeout().orElse(this.timeout);
    }

    public OkHttpClient httpClient() {
        return this.httpClient;
    }

    public OkHttpClient httpClientWithTimeout(RequestOptions requestOptions) {
        if (requestOptions == null) {
            return this.httpClient;
        }
        return this.httpClient
                .newBuilder()
                .callTimeout(requestOptions.getTimeout().get(), requestOptions.getTimeoutTimeUnit())
                .connectTimeout(0, TimeUnit.SECONDS)
                .writeTimeout(0, TimeUnit.SECONDS)
                .readTimeout(0, TimeUnit.SECONDS)
                .build();
    }

    public int maxRetries() {
        return this.maxRetries;
    }

    public Optional<Long> initialRetryDelayMillis() {
        return this.initialRetryDelayMillis;
    }

    public Optional<Long> maxRetryDelayMillis() {
        return this.maxRetryDelayMillis;
    }

    public Optional<Double> retryJitterFactor() {
        return this.retryJitterFactor;
    }

    public Optional<LogConfig> logging() {
        return this.logging;
    }

    public static Builder builder() {
        return new Builder();
    }

    public static class Builder {
        private Environment environment;

        private final Map<String, String> headers = new HashMap<>();

        private final Map<String, Supplier<String>> headerSuppliers = new HashMap<>();

        private int maxRetries = 2;

        private Optional<Long> initialRetryDelayMillis = Optional.empty();

        private Optional<Long> maxRetryDelayMillis = Optional.empty();

        private Optional<Double> retryJitterFactor = Optional.empty();

        private Optional<Integer> timeout = Optional.empty();

        private OkHttpClient httpClient = null;

        private Optional<LogConfig> logging = Optional.empty();

        public Builder environment(Environment environment) {
            this.environment = environment;
            return this;
        }

        public Builder addHeader(String key, String value) {
            if (value != null) {
                this.headers.put(key, value);
            }
            return this;
        }

        public Builder addHeader(String key, Supplier<String> value) {
            this.headerSuppliers.put(key, value);
            return this;
        }

        /**
         * Override the timeout in seconds. Defaults to 60 seconds.
         */
        public Builder timeout(int timeout) {
            this.timeout = Optional.of(timeout);
            return this;
        }

        /**
         * Override the timeout in seconds. Defaults to 60 seconds.
         */
        public Builder timeout(Optional<Integer> timeout) {
            this.timeout = timeout;
            return this;
        }

        /**
         * Override the maximum number of retries. Defaults to 2 retries.
         */
        public Builder maxRetries(int maxRetries) {
            this.maxRetries = maxRetries;
            return this;
        }

        /**
         * Override the initial delay (in milliseconds) used for exponential backoff between retries. Defaults to 1000 milliseconds.
         */
        public Builder initialRetryDelayMillis(long initialRetryDelayMillis) {
            this.initialRetryDelayMillis = Optional.of(initialRetryDelayMillis);
            return this;
        }

        /**
         * Override the maximum delay (in milliseconds) between retries. Defaults to 60000 milliseconds.
         */
        public Builder maxRetryDelayMillis(long maxRetryDelayMillis) {
            this.maxRetryDelayMillis = Optional.of(maxRetryDelayMillis);
            return this;
        }

        /**
         * Override the jitter factor (between 0 and 1) applied to retry delays. Defaults to 0.2.
         */
        public Builder retryJitterFactor(double retryJitterFactor) {
            this.retryJitterFactor = Optional.of(retryJitterFactor);
            return this;
        }

        public Builder httpClient(OkHttpClient httpClient) {
            this.httpClient = httpClient;
            return this;
        }

        /**
         * Configure logging for the SDK. Silent by default — no log output unless explicitly configured.
         */
        public Builder logging(LogConfig logging) {
            this.logging = Optional.of(logging);
            return this;
        }

        public ClientOptions build() {
            OkHttpClient.Builder httpClientBuilder =
                    this.httpClient != null ? this.httpClient.newBuilder() : new OkHttpClient.Builder();

            if (this.httpClient != null) {
                timeout.ifPresent(timeout -> httpClientBuilder
                        .callTimeout(timeout, TimeUnit.SECONDS)
                        .connectTimeout(0, TimeUnit.SECONDS)
                        .writeTimeout(0, TimeUnit.SECONDS)
                        .readTimeout(0, TimeUnit.SECONDS));
            } else {
                httpClientBuilder
                        .callTimeout(this.timeout.orElse(60), TimeUnit.SECONDS)
                        .connectTimeout(0, TimeUnit.SECONDS)
                        .writeTimeout(0, TimeUnit.SECONDS)
                        .readTimeout(0, TimeUnit.SECONDS)
                        .addInterceptor(new RetryInterceptor(
                                this.maxRetries,
                                this.initialRetryDelayMillis,
                                this.maxRetryDelayMillis,
                                this.retryJitterFactor));
            }

            Logger logger = Logger.from(this.logging);
            httpClientBuilder.addInterceptor(new LoggingInterceptor(logger));
            httpClientBuilder.addInterceptor(new ResponseDecompressionInterceptor());

            this.httpClient = httpClientBuilder.build();
            this.timeout = Optional.of(httpClient.callTimeoutMillis() / 1000);

            return new ClientOptions(
                    environment,
                    headers,
                    headerSuppliers,
                    httpClient,
                    this.timeout.get(),
                    this.maxRetries,
                    this.initialRetryDelayMillis,
                    this.maxRetryDelayMillis,
                    this.retryJitterFactor,
                    this.logging);
        }

        /**
         * Create a new Builder initialized with values from an existing ClientOptions
         */
        public static Builder from(ClientOptions clientOptions) {
            Builder builder = new Builder();
            builder.environment = clientOptions.environment();
            builder.timeout = Optional.of(clientOptions.timeout(null));
            builder.httpClient = clientOptions.httpClient();
            builder.headers.putAll(clientOptions.headers);
            builder.headerSuppliers.putAll(clientOptions.headerSuppliers);
            builder.maxRetries = clientOptions.maxRetries();
            builder.initialRetryDelayMillis = clientOptions.initialRetryDelayMillis();
            builder.maxRetryDelayMillis = clientOptions.maxRetryDelayMillis();
            builder.retryJitterFactor = clientOptions.retryJitterFactor();
            builder.logging = clientOptions.logging();
            return builder;
        }
    }
}