feat(horses-service): remove legacy configuration and repository classes

- Deleted outdated `ApplicationConfiguration` and `HorseRepositoryImpl` classes.
- Migrated to streamlined modular Gradle configuration in `build.gradle.kts`.
- Updated domain models and dependencies to use multiplatform and serialization plugins.
- Added modular setup for `horses` namespace in `settings.gradle.kts`.
- Reorganized database configuration with minimal JDBC bindings for development.

Signed-off-by: Stefan Mogeritsch <stefan.mo.co@gmail.com>

backend/services/horses/horses-service/build.gradle.kts

@@ -1,12 +1,10 @@
 plugins {
-    // KORREKTUR: Alle Plugins werden jetzt konsistent über den Version Catalog geladen.
-    alias(libs.plugins.kotlin.jvm)
-    alias(libs.plugins.kotlin.spring)
+  alias(libs.plugins.kotlinJvm)
+  alias(libs.plugins.kotlinSpring)
     alias(libs.plugins.spring.boot)
     alias(libs.plugins.spring.dependencyManagement)
 }
 
-// Der springBoot-Block konfiguriert die Anwendung, wenn sie als JAR-Datei ausgeführt wird.
 springBoot {
     mainClass.set("at.mocode.horses.service.HorsesServiceApplicationKt")
 }
@@ -17,16 +15,9 @@ dependencies {
     implementation(projects.core.coreDomain)
     implementation(projects.core.coreUtils)
     implementation(projects.horses.horsesDomain)
-    implementation(projects.horses.horsesApplication)
+  // horses-common: ON HOLD – veraltete API-Referenzen
+  // implementation(projects.horses.horsesCommon)
     implementation(projects.horses.horsesInfrastructure)
-    implementation(projects.horses.horsesApi)
-
-    // Infrastruktur-Clients
-    implementation(projects.infrastructure.cache.redisCache)
-    implementation(projects.infrastructure.messaging.messagingClient)
-    implementation(projects.infrastructure.monitoring.monitoringClient)
-
-    // KORREKTUR: Alle externen Abhängigkeiten werden jetzt über den Version Catalog bezogen.
 
     // Spring Boot Starters
     implementation(libs.spring.boot.starter.web)
@@ -42,11 +33,10 @@ dependencies {
     runtimeOnly(libs.postgresql.driver)
     testRuntimeOnly(libs.h2.driver)
 
-
     // Testing
     testImplementation(projects.platform.platformTesting)
     testImplementation(libs.spring.boot.starter.test)
-    testImplementation(libs.logback.classic)  // SLF4J provider for tests
+  testImplementation(libs.logback.classic)
 }
 
 tasks.test {

backend/services/horses/horses-service/src/main/kotlin/at/mocode/horses/service/config/ApplicationConfiguration.kt

@@ -1,60 +0,0 @@
-package at.mocode.horses.service.config
-
-import at.mocode.horses.application.usecase.CreateHorseUseCase
-import at.mocode.horses.application.usecase.TransactionalCreateHorseUseCase
-import at.mocode.horses.application.usecase.UpdateHorseUseCase
-import at.mocode.horses.application.usecase.DeleteHorseUseCase
-import at.mocode.horses.application.usecase.GetHorseUseCase
-import at.mocode.horses.domain.repository.HorseRepository
-import org.springframework.context.annotation.Bean
-import org.springframework.context.annotation.Configuration
-
-/**
- * Application configuration for the Horses Service.
- *
- * This configuration wires the use cases as Spring beans.
- */
-@Configuration
-class ApplicationConfiguration {
-
-    /**
-     * Creates the CreateHorseUseCase as a Spring bean.
-     */
-    @Bean
-    fun createHorseUseCase(horseRepository: HorseRepository): CreateHorseUseCase {
-        return CreateHorseUseCase(horseRepository)
-    }
-
-    /**
-     * Creates the TransactionalCreateHorseUseCase as a Spring bean.
-     * This version ensures all database operations run within a single transaction.
-     */
-    @Bean
-    fun transactionalCreateHorseUseCase(horseRepository: HorseRepository): TransactionalCreateHorseUseCase {
-        return TransactionalCreateHorseUseCase(horseRepository)
-    }
-
-    /**
-     * Creates the UpdateHorseUseCase as a Spring bean.
-     */
-    @Bean
-    fun updateHorseUseCase(horseRepository: HorseRepository): UpdateHorseUseCase {
-        return UpdateHorseUseCase(horseRepository)
-    }
-
-    /**
-     * Creates the DeleteHorseUseCase as a Spring bean.
-     */
-    @Bean
-    fun deleteHorseUseCase(horseRepository: HorseRepository): DeleteHorseUseCase {
-        return DeleteHorseUseCase(horseRepository)
-    }
-
-    /**
-     * Creates the GetHorseUseCase as a Spring bean.
-     */
-    @Bean
-    fun getHorseUseCase(horseRepository: HorseRepository): GetHorseUseCase {
-        return GetHorseUseCase(horseRepository)
-    }
-}

backend/services/horses/horses-service/src/main/kotlin/at/mocode/horses/service/config/DatabaseConfiguration.kt

@@ -1,106 +1,37 @@
 package at.mocode.horses.service.config
 
-import at.mocode.core.utils.database.DatabaseConfig
-import at.mocode.core.utils.database.DatabaseFactory
 import at.mocode.horses.infrastructure.persistence.HorseTable
-import org.springframework.boot.context.properties.ConfigurationProperties
+import at.mocode.horses.infrastructure.persistence.ZnsClubTable
+import at.mocode.horses.infrastructure.persistence.ZnsPersonTable
+import jakarta.annotation.PostConstruct
+import org.jetbrains.exposed.v1.jdbc.Database
+import org.jetbrains.exposed.v1.jdbc.SchemaUtils
+import org.jetbrains.exposed.v1.jdbc.transactions.transaction
+import org.slf4j.LoggerFactory
+import org.springframework.beans.factory.annotation.Value
 import org.springframework.context.annotation.Configuration
 import org.springframework.context.annotation.Profile
-import org.springframework.stereotype.Component
-import jakarta.annotation.PostConstruct
-import jakarta.annotation.PreDestroy
-import org.slf4j.LoggerFactory
-import org.jetbrains.exposed.sql.SchemaUtils
-import org.jetbrains.exposed.sql.transactions.transaction
 
 /**
- * Database configuration for the Horses Service.
- *
- * This configuration ensures that Database.connect() is called properly
- * before any Exposed operations are performed.
+ * Minimale Datenbank-Konfiguration für den Horses-Service (Dev-Profil).
+ * Verbindet sich direkt via JDBC und legt die Tabellen an.
  */
 @Configuration
-@Profile("!test")
-class HorsesDatabaseConfiguration {
-
+@Profile("dev")
+class HorsesDatabaseConfiguration(
+  @Value("\${spring.datasource.url}") private val jdbcUrl: String,
+  @Value("\${spring.datasource.username}") private val username: String,
+  @Value("\${spring.datasource.password}") private val password: String
+) {
     private val log = LoggerFactory.getLogger(HorsesDatabaseConfiguration::class.java)
 
     @PostConstruct
     fun initializeDatabase() {
-        log.info("Initializing database schema for Horses Service...")
-
-        try {
-            // Database connection is already initialized by the gateway
-            // Only initialize the schema for this service
-            transaction {
-                SchemaUtils.createMissingTablesAndColumns(HorseTable)
-                log.info("Horse database schema initialized successfully")
-            }
-        } catch (e: Exception) {
-            log.error("Failed to initialize database schema", e)
-            throw e
-        }
-    }
-
-    @PreDestroy
-    fun closeDatabase() {
-        log.info("Closing database connection for Horses Service...")
-        try {
-            DatabaseFactory.close()
-            log.info("Database connection closed successfully")
-        } catch (e: Exception) {
-            log.error("Error closing database connection", e)
-        }
-    }
-}
-
-/**
- * Test-specific database configuration.
- */
-@Configuration
-@Profile("test")
-class HorsesTestDatabaseConfiguration {
-
-    private val log = LoggerFactory.getLogger(HorsesTestDatabaseConfiguration::class.java)
-
-    @PostConstruct
-    fun initializeTestDatabase() {
-        log.info("Initializing test database connection for Horses Service...")
-
-        try {
-            // Use H2 in-memory database for tests
-            val testConfig = DatabaseConfig(
-                jdbcUrl = "jdbc:h2:mem:horses_test;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE",
-                username = "sa",
-                password = "",
-                driverClassName = "org.h2.Driver",
-                maxPoolSize = 5,
-                minPoolSize = 1,
-                autoMigrate = true
-            )
-
-            DatabaseFactory.init(testConfig)
-            log.info("Test database connection initialized successfully")
-
-            // Initialize database schema for tests
-            transaction {
-                SchemaUtils.createMissingTablesAndColumns(HorseTable)
-                log.info("Test horse database schema initialized successfully")
-            }
-        } catch (e: Exception) {
-            log.error("Failed to initialize test database connection", e)
-            throw e
-        }
-    }
-
-    @PreDestroy
-    fun closeTestDatabase() {
-        log.info("Closing test database connection for Horses Service...")
-        try {
-            DatabaseFactory.close()
-            log.info("Test database connection closed successfully")
-        } catch (e: Exception) {
-            log.error("Error closing test database connection", e)
+      log.info("Initialisiere Datenbank-Schema für Horses-Service...")
+      Database.connect(jdbcUrl, user = username, password = password)
+      transaction {
+        SchemaUtils.createMissingTablesAndColumns(HorseTable, ZnsPersonTable, ZnsClubTable)
+        log.info("Datenbank-Schema erfolgreich initialisiert")
         }
     }
 }