Auto-Configuration

/**
 * Auto-configuration for jOOQ that sets up DSLContext, Configuration, and supporting beans
 * Activates when DSLContext is on classpath and DataSource bean is available
 */
@AutoConfiguration(after = { DataSourceAutoConfiguration.class, TransactionAutoConfiguration.class })
@ConditionalOnClass(DSLContext.class)
@ConditionalOnBean(DataSource.class)
@EnableConfigurationProperties(JooqProperties.class)
public class JooqAutoConfiguration {
    
    /**
     * Creates DataSource-based connection provider wrapped with transaction awareness
     * @param dataSource the application's primary DataSource
     * @return DataSourceConnectionProvider configured with TransactionAwareDataSourceProxy
     */
    @Bean
    @ConditionalOnMissingBean(ConnectionProvider.class)
    public DataSourceConnectionProvider dataSourceConnectionProvider(DataSource dataSource);
    
    /**
     * Creates Spring transaction provider for jOOQ when PlatformTransactionManager is available
     * @param txManager Spring's transaction manager
     * @return SpringTransactionProvider that integrates jOOQ with Spring transactions
     */
    @Bean
    @ConditionalOnBean(PlatformTransactionManager.class)
    @ConditionalOnMissingBean(TransactionProvider.class)
    public SpringTransactionProvider transactionProvider(PlatformTransactionManager txManager);
    
    /**
     * Creates execute listener provider for exception translation
     * @param exceptionTranslatorExecuteListener the exception translator listener
     * @return DefaultExecuteListenerProvider configured with exception translation
     */
    @Bean
    @Order(0)
    public DefaultExecuteListenerProvider jooqExceptionTranslatorExecuteListenerProvider(
        ExceptionTranslatorExecuteListener exceptionTranslatorExecuteListener);
    
    /**
     * Creates default exception translator execute listener
     * @return Default implementation of ExceptionTranslatorExecuteListener
     */
    @Bean
    @ConditionalOnMissingBean
    public ExceptionTranslatorExecuteListener jooqExceptionTranslator();
    
    /**
     * Creates the main jOOQ DSL context for performing database operations
     * @param configuration jOOQ configuration with all dependencies
     * @return DefaultDSLContext ready for dependency injection
     */
    @Bean
    @ConditionalOnMissingBean(DSLContext.class)
    public DefaultDSLContext dslContext(org.jooq.Configuration configuration);
    
    /**
     * Creates jOOQ configuration with all necessary components
     * @param properties configuration properties from spring.jooq.*
     * @param connectionProvider database connection provider
     * @param dataSource primary data source for SQL dialect detection
     * @param transactionProvider optional Spring transaction provider
     * @param executeListenerProviders collection of execute listener providers
     * @param configurationCustomizers collection of configuration customizers
     * @param settingsProvider optional jOOQ settings
     * @return Fully configured DefaultConfiguration
     */
    @Bean
    @ConditionalOnMissingBean(org.jooq.Configuration.class)
    DefaultConfiguration jooqConfiguration(JooqProperties properties, 
                                          ConnectionProvider connectionProvider,
                                          DataSource dataSource, 
                                          ObjectProvider<TransactionProvider> transactionProvider,
                                          ObjectProvider<ExecuteListenerProvider> executeListenerProviders,
                                          ObjectProvider<DefaultConfigurationCustomizer> configurationCustomizers,
                                          ObjectProvider<Settings> settingsProvider);
    
    /**
     * Creates jOOQ Settings from external configuration file when spring.jooq.config is specified
     * @param properties configuration properties containing config file location
     * @return Settings loaded from XML configuration file
     * @throws IOException if config file cannot be read
     * @throws JaxbNotAvailableException if JAXB is not available for XML parsing
     */
    @Bean
    @ConditionalOnProperty("spring.jooq.config")
    @ConditionalOnMissingBean(Settings.class)
    Settings settings(JooqProperties properties) throws IOException;
}

// Auto-configured DSLContext is available for injection
@Service
public class BookService {
    
    @Autowired
    private DSLContext dsl;
    
    public List<Book> findBooksByAuthor(String author) {
        return dsl.selectFrom(BOOK)
                  .where(BOOK.AUTHOR.eq(author))
                  .fetchInto(Book.class);
    }
}

// Custom configuration can be provided via customizer
@Component
public class MyJooqCustomizer implements DefaultConfigurationCustomizer {
    
    @Override
    public void customize(DefaultConfiguration configuration) {
        // Add custom configuration like converters, listeners, etc.
        configuration.set(new MyCustomExecuteListener());
    }
}

@Configuration
public class CustomJooqConfiguration {
    
    // Override default DSLContext
    @Bean
    @Primary
    public DSLContext customDslContext(org.jooq.Configuration configuration) {
        return new DefaultDSLContext(configuration);
    }
    
    // Override connection provider
    @Bean
    @Primary
    public ConnectionProvider customConnectionProvider(DataSource dataSource) {
        return new DataSourceConnectionProvider(dataSource);
    }
}

### Database Initialization Integration

Integration component that ensures jOOQ beans depend on database initialization completion.

```java { .api }
/**
 * DependsOnDatabaseInitializationDetector for jOOQ
 * Ensures DSLContext beans wait for database initialization to complete
 */
class JooqDependsOnDatabaseInitializationDetector extends AbstractBeansOfTypeDependsOnDatabaseInitializationDetector {
    
    /**
     * Returns the bean types that depend on database initialization
     * @return Set containing DSLContext.class
     */
    @Override
    protected Set<Class<?>> getDependsOnDatabaseInitializationBeanTypes();
}

/**
 * Internal loader for jOOQ Settings from XML configuration files
 * Implements XML External Entity Prevention security measures
 * Used when spring.jooq.config property points to an XML configuration file
 */
private static final class JaxbSettingsLoader {
    
    /**
     * Load Settings from InputStream with secure XML parsing
     * @param inputStream the input stream containing XML configuration
     * @return Settings object parsed from XML
     * @throws IllegalStateException if XML parsing fails
     */
    private Settings load(InputStream inputStream);
    
    /**
     * Create secure SAX parser factory with security features enabled
     * @return SAXParserFactory configured for secure XML processing
     * @throws ParserConfigurationException if parser configuration fails
     * @throws SAXNotRecognizedException if security features not supported
     * @throws SAXNotSupportedException if security features not supported
     */
    private SAXParserFactory createParserFactory() 
        throws ParserConfigurationException, SAXNotRecognizedException, SAXNotSupportedException;
}

// This configuration will ensure proper ordering
@Configuration
public class DatabaseConfig {
    
    @Bean
    @FlywayDataSource
    public DataSource dataSource() {
        return new HikariDataSource();
    }
    
    // DSLContext will automatically wait for Flyway migrations
    // No additional configuration needed - handled by detector
    @Autowired
    private DSLContext dsl; // Available after migrations complete
}