UnifyAutoConfig.java

/* 
 * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
 */
package com.apideck.unify;

import org.springframework.boot.autoconfigure.AutoConfiguration;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import java.util.concurrent.TimeUnit;

import com.apideck.unify.utils.BackoffStrategy;
import com.apideck.unify.utils.HTTPClient;
import com.apideck.unify.utils.RetryConfig;
import com.apideck.unify.utils.SpeakeasyHTTPClient;
import java.lang.IllegalStateException;
import java.lang.String;
import java.lang.System;
import java.util.Optional;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.function.Consumer;


/**
 * Spring Boot Auto Configuration for Apideck SDK
 * This configuration class automatically configures the Apideck SDK
 * when Spring Boot detects it on the classpath.
 */
@AutoConfiguration
@ConditionalOnClass(Apideck.class)
@EnableConfigurationProperties(UnifyAutoConfigProperties.class)
public class UnifyAutoConfig {

    /**
     * Constructor.
     */
    public UnifyAutoConfig() {
    }

    /**
     * Creates a RetryConfig bean from properties if retry is enabled.
     * 
     * @param properties the configuration properties
     * @return A configured RetryConfig instance
     */
    @Bean
    @ConditionalOnMissingBean
    @ConditionalOnProperty(prefix = "unify.retry-config", name = "strategy")
    public RetryConfig retryConfig(UnifyAutoConfigProperties properties) {
        UnifyAutoConfigProperties.RetryConfig retryProps = properties.getRetryConfig();
        
        if (RetryConfig.Strategy.BACKOFF.equals(retryProps.getStrategy())) {
            UnifyAutoConfigProperties.RetryConfig.Backoff backoff = retryProps.getBackoff();
            return RetryConfig.builder()
                .backoff(
                    BackoffStrategy.builder()
                        .initialInterval(backoff.getInitialInterval().toMillis(), TimeUnit.MILLISECONDS)
                        .maxInterval(backoff.getMaxInterval().toMillis(), TimeUnit.MILLISECONDS)
                        .maxElapsedTime(backoff.getMaxElapsedTime().toMillis(), TimeUnit.MILLISECONDS)
                        .baseFactor(backoff.getBaseFactor())
                        .jitterFactor(backoff.getJitterFactor())
                        .retryConnectError(backoff.isRetryConnectError())
                        .retryReadTimeoutError(backoff.isRetryReadTimeoutError())
                        .build()
                )
                .build();
        }
        
        // Default retry config for other strategies
        return RetryConfig.builder().build();
    }
    /**
     * Creates a {@code Consumer<String>} bean for HTTP debug logging if none exists.
     * This logger is used by the SpeakeasyHTTPClient for debug output when debug logging is enabled.
     * By default, it logs to {@code System.out}, but can be customized by providing your own {@code Consumer<String>} bean.
     *
     * @return A {@code Consumer<String>} that logs messages to {@code System.out}
     */
    @Bean
    @ConditionalOnMissingBean
    public Consumer<String> httpLogger() {
        return System.out::println;
    }
    /**
     * Creates an HTTPClient bean if none exists.
     *
     * @param properties the configuration properties
     * @param httpLogger the logger for HTTP debug output
     * @return A configured HTTPClient instance
     */
    @Bean
    @ConditionalOnMissingBean
    public HTTPClient httpClient(UnifyAutoConfigProperties properties, Consumer<String> httpLogger) {
        UnifyAutoConfigProperties.HttpClient httpClientProps = properties.getHttpClient();

        // Configure the static logger
        SpeakeasyHTTPClient.setLogger(httpLogger);

        if (httpClientProps != null) {
            // Configure debug logging
            SpeakeasyHTTPClient.setDebugLogging(httpClientProps.isEnableDebugLogging());

            // Configure redacted headers
            if (httpClientProps.getRedactedHeaders() != null && !httpClientProps.getRedactedHeaders().isEmpty()) {
                SpeakeasyHTTPClient.setRedactedHeaders(httpClientProps.getRedactedHeaders());
            }
        }

        return new SpeakeasyHTTPClient();
    }
    /**
     * Creates a SecuritySource bean if none exists and security properties are configured.
     *
     * @param properties the configuration properties
     * @return A configured SecuritySource instance
     */
    @Bean
    @ConditionalOnMissingBean
    @ConditionalOnPropertyPrefix(prefix = "unify.security")
    public SecuritySource securitySource(UnifyAutoConfigProperties properties) {UnifyAutoConfigProperties.Security securityProps = properties.getSecurity();
        com.apideck.unify.models.components.Security.Builder securityBuilder = com.apideck.unify.models.components.Security.builder();
        boolean hasAnySecurityConfiguration = false;
        // Build apiKey security from direct properties (primitive value)
        if (securityProps.getApiKey() != null) {
            securityBuilder.apiKey(securityProps.getApiKey());
            hasAnySecurityConfiguration = true;
        }
        
        if (!hasAnySecurityConfiguration) {
            throw new IllegalStateException("Security configuration is present but no security options are configured. " +
                "Please configure at least one security option in your application properties.");
        }
        
        return SecuritySource.of(securityBuilder.build());
    }

    /**
     * Creates the SDKConfiguration bean as the single source of truth for all SDK configuration.
     *
     * @param properties the configuration properties
     * @param httpClient the HTTP client bean
     * @param hooks the hooks bean
     * @param asyncHooks the async hooks bean
     * @param securitySource the security source bean (optional)
     * @param globals the globals configuration bean
     * @param retryConfig the retry config bean (optional)
     * @return A configured SDKConfiguration instance
     */
    @Bean
    @ConditionalOnMissingBean
    public SDKConfiguration sdkConfiguration(
            UnifyAutoConfigProperties properties,
            HTTPClient httpClient,
            com.apideck.unify.utils.Hooks hooks,
            com.apideck.unify.utils.AsyncHooks asyncHooks,
            SecuritySource securitySource,
            com.apideck.unify.utils.Globals globals,
            Optional<RetryConfig> retryConfig) {
        
        SDKConfiguration sdkConfiguration = new SDKConfiguration();
        
        sdkConfiguration.setClient(httpClient);
        
        sdkConfiguration.setHooks(hooks);
        sdkConfiguration.setAsyncHooks(asyncHooks);
        sdkConfiguration.setSecuritySource(securitySource);
        
        if (properties.getServerUrl() != null) {
            sdkConfiguration.setServerUrl(properties.getServerUrl());
        }
        sdkConfiguration.setServerIdx(properties.getServerIdx());
        sdkConfiguration.setGlobals(globals);
        
        sdkConfiguration.setRetryConfig(retryConfig);
        
        return sdkConfiguration;
    }

    /**
     * Creates the main SDK bean using the configured SDKConfiguration.
     *
     * @param sdkConfiguration the configured SDKConfiguration bean
     * @return A configured Apideck instance
     */
    @Bean
    @ConditionalOnMissingBean
    public Apideck apideck(SDKConfiguration sdkConfiguration) {
        return new Apideck(sdkConfiguration);
    }

    /**
     * Creates a Globals configuration bean if none exists, populated from properties.
     *
     * @param properties the configuration properties
     * @return A configured Globals instance
     */
    @Bean
    @ConditionalOnMissingBean
    public com.apideck.unify.utils.Globals globals(UnifyAutoConfigProperties properties) {
        com.apideck.unify.utils.Globals globals = new com.apideck.unify.utils.Globals();
        
        // Populate globals from properties
        UnifyAutoConfigProperties.Globals globalProps = properties.getGlobals();
        if (globalProps.getConsumerId() != null) {
            globals.putParam("header", "x-apideck-consumer-id", globalProps.getConsumerId());
        }
        if (globalProps.getAppId() != null) {
            globals.putParam("header", "x-apideck-app-id", globalProps.getAppId());
        }
        
        return globals;
    }

    /**
     * Creates an AsyncHooks bean if none exists.
     * 
     * @return A configured AsyncHooks instance
     */
    @Bean
    @ConditionalOnMissingBean
    public com.apideck.unify.utils.AsyncHooks asyncHooks() {
        return new com.apideck.unify.utils.AsyncHooks();
    }

    /**
     * Creates a ScheduledExecutorService for async retry operations if none exists.
     * 
     * @return A configured ScheduledExecutorService instance
     */
    @Bean
    @ConditionalOnMissingBean
    public ScheduledExecutorService retryScheduler() {
        return Executors.newSingleThreadScheduledExecutor();
    }

    /**
     * Creates a Hooks configuration bean if none exists.
     *
     * @return A configured Hooks instance
     */
    @Bean
    @ConditionalOnMissingBean
    public com.apideck.unify.utils.Hooks hooks() {
        return new com.apideck.unify.utils.Hooks();
    }
    /**
     * Creates a Accounting sub-SDK bean if none exists.
     *
     * @param apideck the main SDK instance
     * @return A configured Accounting instance
     */
    @Bean
    @ConditionalOnMissingBean
    public Accounting accounting(Apideck apideck) {
        return apideck.accounting();
    }
    /**
     * Creates a Ats sub-SDK bean if none exists.
     *
     * @param apideck the main SDK instance
     * @return A configured Ats instance
     */
    @Bean
    @ConditionalOnMissingBean
    public Ats ats(Apideck apideck) {
        return apideck.ats();
    }
    /**
     * Creates a Crm sub-SDK bean if none exists.
     *
     * @param apideck the main SDK instance
     * @return A configured Crm instance
     */
    @Bean
    @ConditionalOnMissingBean
    public Crm crm(Apideck apideck) {
        return apideck.crm();
    }
    /**
     * Creates a Ecommerce sub-SDK bean if none exists.
     *
     * @param apideck the main SDK instance
     * @return A configured Ecommerce instance
     */
    @Bean
    @ConditionalOnMissingBean
    public Ecommerce ecommerce(Apideck apideck) {
        return apideck.ecommerce();
    }
    /**
     * Creates a FileStorage sub-SDK bean if none exists.
     *
     * @param apideck the main SDK instance
     * @return A configured FileStorage instance
     */
    @Bean
    @ConditionalOnMissingBean
    public FileStorage fileStorage(Apideck apideck) {
        return apideck.fileStorage();
    }
    /**
     * Creates a Hris sub-SDK bean if none exists.
     *
     * @param apideck the main SDK instance
     * @return A configured Hris instance
     */
    @Bean
    @ConditionalOnMissingBean
    public Hris hris(Apideck apideck) {
        return apideck.hris();
    }
    /**
     * Creates a Sms sub-SDK bean if none exists.
     *
     * @param apideck the main SDK instance
     * @return A configured Sms instance
     */
    @Bean
    @ConditionalOnMissingBean
    public Sms sms(Apideck apideck) {
        return apideck.sms();
    }
    /**
     * Creates a IssueTracking sub-SDK bean if none exists.
     *
     * @param apideck the main SDK instance
     * @return A configured IssueTracking instance
     */
    @Bean
    @ConditionalOnMissingBean
    public IssueTracking issueTracking(Apideck apideck) {
        return apideck.issueTracking();
    }
    /**
     * Creates a Connector sub-SDK bean if none exists.
     *
     * @param apideck the main SDK instance
     * @return A configured Connector instance
     */
    @Bean
    @ConditionalOnMissingBean
    public Connector connector(Apideck apideck) {
        return apideck.connector();
    }
    /**
     * Creates a Vault sub-SDK bean if none exists.
     *
     * @param apideck the main SDK instance
     * @return A configured Vault instance
     */
    @Bean
    @ConditionalOnMissingBean
    public Vault vault(Apideck apideck) {
        return apideck.vault();
    }
    /**
     * Creates a Webhook sub-SDK bean if none exists.
     *
     * @param apideck the main SDK instance
     * @return A configured Webhook instance
     */
    @Bean
    @ConditionalOnMissingBean
    public Webhook webhook(Apideck apideck) {
        return apideck.webhook();
    }

    /**
     * Creates the async SDK bean if none exists.
     *
     * @param apideck the main SDK instance
     * @param sdkConfiguration the configured SDKConfiguration bean
     * @return A configured AsyncApideck instance
     */
    @Bean
    @ConditionalOnMissingBean
    public AsyncApideck asyncApideck(Apideck apideck, SDKConfiguration sdkConfiguration) {
        return new AsyncApideck(apideck, sdkConfiguration);
    }
    /**
     * Creates an AsyncAccounting sub-SDK bean if none exists.
     *
     * @param asyncApideck the async SDK instance
     * @return A configured AsyncAccounting instance
     */
    @Bean
    @ConditionalOnMissingBean
    public AsyncAccounting asyncAccounting(AsyncApideck asyncApideck) {
        return asyncApideck.accounting();
    }
    /**
     * Creates an AsyncAts sub-SDK bean if none exists.
     *
     * @param asyncApideck the async SDK instance
     * @return A configured AsyncAts instance
     */
    @Bean
    @ConditionalOnMissingBean
    public AsyncAts asyncAts(AsyncApideck asyncApideck) {
        return asyncApideck.ats();
    }
    /**
     * Creates an AsyncCrm sub-SDK bean if none exists.
     *
     * @param asyncApideck the async SDK instance
     * @return A configured AsyncCrm instance
     */
    @Bean
    @ConditionalOnMissingBean
    public AsyncCrm asyncCrm(AsyncApideck asyncApideck) {
        return asyncApideck.crm();
    }
    /**
     * Creates an AsyncEcommerce sub-SDK bean if none exists.
     *
     * @param asyncApideck the async SDK instance
     * @return A configured AsyncEcommerce instance
     */
    @Bean
    @ConditionalOnMissingBean
    public AsyncEcommerce asyncEcommerce(AsyncApideck asyncApideck) {
        return asyncApideck.ecommerce();
    }
    /**
     * Creates an AsyncFileStorage sub-SDK bean if none exists.
     *
     * @param asyncApideck the async SDK instance
     * @return A configured AsyncFileStorage instance
     */
    @Bean
    @ConditionalOnMissingBean
    public AsyncFileStorage asyncFileStorage(AsyncApideck asyncApideck) {
        return asyncApideck.fileStorage();
    }
    /**
     * Creates an AsyncHris sub-SDK bean if none exists.
     *
     * @param asyncApideck the async SDK instance
     * @return A configured AsyncHris instance
     */
    @Bean
    @ConditionalOnMissingBean
    public AsyncHris asyncHris(AsyncApideck asyncApideck) {
        return asyncApideck.hris();
    }
    /**
     * Creates an AsyncSms sub-SDK bean if none exists.
     *
     * @param asyncApideck the async SDK instance
     * @return A configured AsyncSms instance
     */
    @Bean
    @ConditionalOnMissingBean
    public AsyncSms asyncSms(AsyncApideck asyncApideck) {
        return asyncApideck.sms();
    }
    /**
     * Creates an AsyncIssueTracking sub-SDK bean if none exists.
     *
     * @param asyncApideck the async SDK instance
     * @return A configured AsyncIssueTracking instance
     */
    @Bean
    @ConditionalOnMissingBean
    public AsyncIssueTracking asyncIssueTracking(AsyncApideck asyncApideck) {
        return asyncApideck.issueTracking();
    }
    /**
     * Creates an AsyncConnector sub-SDK bean if none exists.
     *
     * @param asyncApideck the async SDK instance
     * @return A configured AsyncConnector instance
     */
    @Bean
    @ConditionalOnMissingBean
    public AsyncConnector asyncConnector(AsyncApideck asyncApideck) {
        return asyncApideck.connector();
    }
    /**
     * Creates an AsyncVault sub-SDK bean if none exists.
     *
     * @param asyncApideck the async SDK instance
     * @return A configured AsyncVault instance
     */
    @Bean
    @ConditionalOnMissingBean
    public AsyncVault asyncVault(AsyncApideck asyncApideck) {
        return asyncApideck.vault();
    }
    /**
     * Creates an AsyncWebhook sub-SDK bean if none exists.
     *
     * @param asyncApideck the async SDK instance
     * @return A configured AsyncWebhook instance
     */
    @Bean
    @ConditionalOnMissingBean
    public AsyncWebhook asyncWebhook(AsyncApideck asyncApideck) {
        return asyncApideck.webhook();
    }
}