chore(ci): Align GH Workflows with Docker SSoT, new paths; minimal SSoT guard; staticAnalysis (#23)

* chore(MP-21): snapshot pre-refactor state (Epic 1)

* chore(MP-22): scaffold new repo structure, relocate Docker Compose, move frontend/backend modules, update Makefile; add docs mapping and env template

* MP-22 Epic 2: Erfolgreich umgesetzt und verifiziert

* MP-23 Epic 3: Gradle/Build Governance zentralisieren

* MP-23 Epic 3: Gradle/Build Governance zentralisieren

* chore(devops)!: Docker-SSoT (.env) konsolidiert, Compose-Mounts ergänzt, Makefile entfernt

- ENV Single Source of Truth
  - docker/.env.example neu (inkl. REDIS_PASSWORD, Ports, Build-Overrides)
  - config/.env(.example) als DEPRECATED markiert (Verweis auf docker/.env[.example])

- Docker Compose vereinheitlicht (docker/docker-compose.yaml)
  - Postgres: zentralen postgresql.conf mounten (../config/postgres/postgresql.conf)
    und Start mit -c config_file=/etc/postgresql/postgresql.conf
  - Redis: zentralen redis.conf mounten (../config/redis/redis.conf)
    und Start via "redis-server … ${REDIS_PASSWORD:+--requirepass $REDIS_PASSWORD}"
  - Web-Nginx: ../config/nginx/nginx.prod.conf → /etc/nginx/nginx.conf (ro)
  - Monitoring: Prometheus/Grafana nutzen ../config/monitoring/* als SSoT

- Frontend/DI/Network (MP-23 Grundlage)
  - :frontend:core:network Modul mit Koin `apiClient` (Ktor + JSON/Retry/Timeout/Logging)
  - Plattform-Basis-URL-Auflösung (JVM: ENV API_BASE_URL; JS: globalThis.API_BASE_URL / Same-Origin)
  - Web index.html setzt API_BASE_URL (Query `?apiBaseUrl=…` > Same-Origin > Fallback)

- Build/Gradle & Module-Refs
  - settings.gradle.kts: neue Frontend-/Backend-Pfade bereits inkludiert
  - Features/Shell: Abhängigkeiten auf :frontend:shared / :frontend:core:* angepasst
  - Ping-API-Refs auf :backend:services:ping:ping-api vereinheitlicht

- Dockerfiles angepasst
  - backend/infrastructure/gateway/Dockerfile → Tasks/Pfade auf :backend:gateway
  - backend/services/ping/Dockerfile → Tasks/Pfade auf :backend:services:ping:ping-service

- Static Analysis / Guards
  - config/detekt/detekt.yml hinzugefügt
  - Leichter Arch-Guard (Frontend) gegen manuelle Authorization-Header vorbereitet

- Doku
  - docs/ARCHITECTURE.md (Struktur, Mapping, Next Steps) ergänzt
  - docs/adr/README.md angelegt

BREAKING CHANGES:
- Makefile komplett entfernt (bitte direkt `docker compose` verwenden)
- ENV-Quelle ist jetzt docker/.env (statt config/.env oder Root)
- Compose-Datei unter docker/docker-compose.yaml (nicht mehr compose.yaml im Repo-Root)

Verifikation (lokal):
- ENV anlegen: `cp docker/.env.example docker/.env` (Werte anpassen)
- Compose prüfen: `docker compose --env-file docker/.env -f docker/docker-compose.yaml config`
- Infrastruktur: `docker compose --env-file docker/.env -f docker/docker-compose.yaml -p meldestelle up -d postgres redis keycloak web-app`
- Services bauen: `docker compose --env-file docker/.env -f docker/docker-compose.yaml -p meldestelle build api-gateway ping-service --no-cache --progress=plain`

Refs: MP-22 (Epic 2), MP-23 (Epic 3)

* chore(devops)!: Docker-SSoT (.env) konsolidiert, Compose-Mounts ergänzt, Makefile entfernt

- ENV Single Source of Truth
  - docker/.env.example neu (inkl. REDIS_PASSWORD, Ports, Build-Overrides)
  - config/.env(.example) als DEPRECATED markiert (Verweis auf docker/.env[.example])

- Docker Compose vereinheitlicht (docker/docker-compose.yaml)
  - Postgres: zentralen postgresql.conf mounten (../config/postgres/postgresql.conf)
    und Start mit -c config_file=/etc/postgresql/postgresql.conf
  - Redis: zentralen redis.conf mounten (../config/redis/redis.conf)
    und Start via "redis-server … ${REDIS_PASSWORD:+--requirepass $REDIS_PASSWORD}"
  - Web-Nginx: ../config/nginx/nginx.prod.conf → /etc/nginx/nginx.conf (ro)
  - Monitoring: Prometheus/Grafana nutzen ../config/monitoring/* als SSoT

- Frontend/DI/Network (MP-23 Grundlage)
  - :frontend:core:network Modul mit Koin `apiClient` (Ktor + JSON/Retry/Timeout/Logging)
  - Plattform-Basis-URL-Auflösung (JVM: ENV API_BASE_URL; JS: globalThis.API_BASE_URL / Same-Origin)
  - Web index.html setzt API_BASE_URL (Query `?apiBaseUrl=…` > Same-Origin > Fallback)

- Build/Gradle & Module-Refs
  - settings.gradle.kts: neue Frontend-/Backend-Pfade bereits inkludiert
  - Features/Shell: Abhängigkeiten auf :frontend:shared / :frontend:core:* angepasst
  - Ping-API-Refs auf :backend:services:ping:ping-api vereinheitlicht

- Dockerfiles angepasst
  - backend/infrastructure/gateway/Dockerfile → Tasks/Pfade auf :backend:gateway
  - backend/services/ping/Dockerfile → Tasks/Pfade auf :backend:services:ping:ping-service

- Static Analysis / Guards
  - config/detekt/detekt.yml hinzugefügt
  - Leichter Arch-Guard (Frontend) gegen manuelle Authorization-Header vorbereitet

- Doku
  - docs/ARCHITECTURE.md (Struktur, Mapping, Next Steps) ergänzt
  - docs/adr/README.md angelegt

BREAKING CHANGES:
- Makefile komplett entfernt (bitte direkt `docker compose` verwenden)
- ENV-Quelle ist jetzt docker/.env (statt config/.env oder Root)
- Compose-Datei unter docker/docker-compose.yaml (nicht mehr compose.yaml im Repo-Root)

Verifikation (lokal):
- ENV anlegen: `cp docker/.env.example docker/.env` (Werte anpassen)
- Compose prüfen: `docker compose --env-file docker/.env -f docker/docker-compose.yaml config`
- Infrastruktur: `docker compose --env-file docker/.env -f docker/docker-compose.yaml -p meldestelle up -d postgres redis keycloak web-app`
- Services bauen: `docker compose --env-file docker/.env -f docker/docker-compose.yaml -p meldestelle build api-gateway ping-service --no-cache --progress=plain`

Refs: MP-22 (Epic 2), MP-23 (Epic 3)

* chore(devops)!: Docker-SSoT (.env) konsolidiert, Compose-Mounts ergänzt, Makefile entfernt

- ENV Single Source of Truth
  - docker/.env.example neu (inkl. REDIS_PASSWORD, Ports, Build-Overrides)
  - config/.env(.example) als DEPRECATED markiert (Verweis auf docker/.env[.example])

- Docker Compose vereinheitlicht (docker/docker-compose.yaml)
  - Postgres: zentralen postgresql.conf mounten (../config/postgres/postgresql.conf)
    und Start mit -c config_file=/etc/postgresql/postgresql.conf
  - Redis: zentralen redis.conf mounten (../config/redis/redis.conf)
    und Start via "redis-server … ${REDIS_PASSWORD:+--requirepass $REDIS_PASSWORD}"
  - Web-Nginx: ../config/nginx/nginx.prod.conf → /etc/nginx/nginx.conf (ro)
  - Monitoring: Prometheus/Grafana nutzen ../config/monitoring/* als SSoT

- Frontend/DI/Network (MP-23 Grundlage)
  - :frontend:core:network Modul mit Koin `apiClient` (Ktor + JSON/Retry/Timeout/Logging)
  - Plattform-Basis-URL-Auflösung (JVM: ENV API_BASE_URL; JS: globalThis.API_BASE_URL / Same-Origin)
  - Web index.html setzt API_BASE_URL (Query `?apiBaseUrl=…` > Same-Origin > Fallback)

- Build/Gradle & Module-Refs
  - settings.gradle.kts: neue Frontend-/Backend-Pfade bereits inkludiert
  - Features/Shell: Abhängigkeiten auf :frontend:shared / :frontend:core:* angepasst
  - Ping-API-Refs auf :backend:services:ping:ping-api vereinheitlicht

- Dockerfiles angepasst
  - backend/infrastructure/gateway/Dockerfile → Tasks/Pfade auf :backend:gateway
  - backend/services/ping/Dockerfile → Tasks/Pfade auf :backend:services:ping:ping-service

- Static Analysis / Guards
  - config/detekt/detekt.yml hinzugefügt
  - Leichter Arch-Guard (Frontend) gegen manuelle Authorization-Header vorbereitet

- Doku
  - docs/ARCHITECTURE.md (Struktur, Mapping, Next Steps) ergänzt
  - docs/adr/README.md angelegt

BREAKING CHANGES:
- Makefile komplett entfernt (bitte direkt `docker compose` verwenden)
- ENV-Quelle ist jetzt docker/.env (statt config/.env oder Root)
- Compose-Datei unter docker/docker-compose.yaml (nicht mehr compose.yaml im Repo-Root)

Verifikation (lokal):
- ENV anlegen: `cp docker/.env.example docker/.env` (Werte anpassen)
- Compose prüfen: `docker compose --env-file docker/.env -f docker/docker-compose.yaml config`
- Infrastruktur: `docker compose --env-file docker/.env -f docker/docker-compose.yaml -p meldestelle up -d postgres redis keycloak web-app`
- Services bauen: `docker compose --env-file docker/.env -f docker/docker-compose.yaml -p meldestelle build api-gateway ping-service --no-cache --progress=plain`

Refs: MP-22 (Epic 2), MP-23 (Epic 3)

* chore(ci): Workflows an Docker-SSoT & neue Struktur angepasst, minimaler SSoT-Guard

- ssot-guard.yml: Option B (minimal) → `docker compose -f docker/docker-compose.yaml config` als Lint
- integration-tests.yml: `./gradlew staticAnalysis` vor Integrationstests
- docs-kdoc-sync.yml: Dokka-Task Fallback (dokkaGfmAll || dokkaGfm), YouTrack-Sync nur wenn Script vorhanden
- deploy-proxmox.yml: Compose-Pfade auf docker/docker-compose.yaml + `--env-file docker/.env`; Build/Test Schritte vereinheitlicht
- ci-main.yml: SSoT-Skripte per `if: hashFiles(...)` guarded, Compose-Lint Fallback; OpenAPI‑Pfad → backend/gateway; ADR‑Pfade → docs/adr/**; `staticAnalysis` in Build integriert
- youtrack-sync.yml: unverändert (funktional)

Refs: MP-22, MP-23

* chore(ci): Workflows an Docker-SSoT & neue Struktur angepasst, minimaler SSoT-Guard

- ssot-guard.yml: Option B (minimal) → `docker compose -f docker/docker-compose.yaml config` als Lint
- integration-tests.yml: `./gradlew staticAnalysis` vor Integrationstests
- docs-kdoc-sync.yml: Dokka-Task Fallback (dokkaGfmAll || dokkaGfm), YouTrack-Sync nur wenn Script vorhanden
- deploy-proxmox.yml: Compose-Pfade auf docker/docker-compose.yaml + `--env-file docker/.env`; Build/Test Schritte vereinheitlicht
- ci-main.yml: SSoT-Skripte per `if: hashFiles(...)` guarded, Compose-Lint Fallback; OpenAPI‑Pfad → backend/gateway; ADR‑Pfade → docs/adr/**; `staticAnalysis` in Build integriert
- youtrack-sync.yml: unverändert (funktional)

Refs: MP-22, MP-23

* fix(ci): create .env from example before validating compose config

* fix(ci): update ssot-guard filename (.yaml) and sync workflow state

* fixing

* fix(webpack): correct sql.js fallback configuration for webpack 5

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

@@ -0,0 +1,30 @@
+plugins {
+    // KORREKTUR: Alle Plugins werden jetzt konsistent über den Version Catalog geladen.
+    alias(libs.plugins.kotlin.jvm)
+    alias(libs.plugins.kotlin.spring)
+    // Das JPA-Plugin wird jetzt ebenfalls zentral verwaltet.
+    alias(libs.plugins.kotlin.jpa)
+}
+
+dependencies {
+    // Interne Module
+    implementation(projects.platform.platformDependencies)
+    implementation(projects.horses.horsesDomain)
+    implementation(projects.horses.horsesApplication)
+    implementation(projects.core.coreDomain)
+    implementation(projects.core.coreUtils)
+    implementation(projects.infrastructure.cache.cacheApi)
+    implementation(projects.infrastructure.eventStore.eventStoreApi)
+    implementation(projects.infrastructure.messaging.messagingClient)
+
+    // KORREKTUR: Alle externen Abhängigkeiten werden jetzt über den Version Catalog bezogen.
+
+    // Spring Data JPA
+    implementation(libs.spring.boot.starter.data.jpa)
+
+    // Datenbank-Treiber
+    runtimeOnly(libs.postgresql.driver)
+
+    // Testing
+    testImplementation(projects.platform.platformTesting)
+}

backend/services/horses/horses-infrastructure/src/main/kotlin/at/mocode/horses/infrastructure/persistence/HorseRepositoryImpl.kt

@@ -0,0 +1,336 @@
+@file:OptIn(kotlin.uuid.ExperimentalUuidApi::class)
+package at.mocode.horses.infrastructure.persistence
+
+import at.mocode.core.domain.model.PferdeGeschlechtE
+import at.mocode.horses.domain.model.DomPferd
+import at.mocode.horses.domain.repository.HorseRepository
+import at.mocode.core.utils.database.DatabaseFactory
+import kotlin.uuid.Uuid
+import kotlinx.datetime.Clock
+import org.jetbrains.exposed.sql.*
+import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
+import org.jetbrains.exposed.sql.statements.UpdateBuilder
+import org.springframework.stereotype.Repository
+
+/**
+ * PostgreSQL implementation of the HorseRepository using Exposed ORM.
+ *
+ * This implementation provides database operations for horse entities,
+ * mapping between the domain model (DomPferd) and the database table (HorseTable).
+ */
+@Repository
+class HorseRepositoryImpl : HorseRepository {
+
+    override suspend fun findById(id: Uuid): DomPferd? = DatabaseFactory.dbQuery {
+        HorseTable.selectAll().where { HorseTable.id eq id }
+            .map { rowToDomPferd(it) }
+            .singleOrNull()
+    }
+
+    override suspend fun findByLebensnummer(lebensnummer: String): DomPferd? = DatabaseFactory.dbQuery {
+        HorseTable.selectAll().where { HorseTable.lebensnummer eq lebensnummer }
+            .map { rowToDomPferd(it) }
+            .singleOrNull()
+    }
+
+    override suspend fun findByChipNummer(chipNummer: String): DomPferd? = DatabaseFactory.dbQuery {
+        HorseTable.selectAll().where { HorseTable.chipNummer eq chipNummer }
+            .map { rowToDomPferd(it) }
+            .singleOrNull()
+    }
+
+    override suspend fun findByPassNummer(passNummer: String): DomPferd? = DatabaseFactory.dbQuery {
+        HorseTable.selectAll().where { HorseTable.passNummer eq passNummer }
+            .map { rowToDomPferd(it) }
+            .singleOrNull()
+    }
+
+    override suspend fun findByOepsNummer(oepsNummer: String): DomPferd? = DatabaseFactory.dbQuery {
+        HorseTable.selectAll().where { HorseTable.oepsNummer eq oepsNummer }
+            .map { rowToDomPferd(it) }
+            .singleOrNull()
+    }
+
+    override suspend fun findByFeiNummer(feiNummer: String): DomPferd? = DatabaseFactory.dbQuery {
+        HorseTable.selectAll().where { HorseTable.feiNummer eq feiNummer }
+            .map { rowToDomPferd(it) }
+            .singleOrNull()
+    }
+
+    override suspend fun findByName(searchTerm: String, limit: Int): List<DomPferd> = DatabaseFactory.dbQuery {
+        HorseTable.selectAll().where { HorseTable.pferdeName like "%$searchTerm%" }
+            .orderBy(HorseTable.pferdeName to SortOrder.ASC)
+            .limit(limit)
+            .map { rowToDomPferd(it) }
+    }
+
+    override suspend fun findByOwnerId(ownerId: Uuid, activeOnly: Boolean): List<DomPferd> = DatabaseFactory.dbQuery {
+        val query = HorseTable.selectAll().where { HorseTable.besitzerId eq ownerId }
+
+        if (activeOnly) {
+            query.andWhere { HorseTable.istAktiv eq true }
+        } else {
+            query
+        }.orderBy(HorseTable.pferdeName to SortOrder.ASC)
+         .map { rowToDomPferd(it) }
+    }
+
+    override suspend fun findByResponsiblePersonId(responsiblePersonId: Uuid, activeOnly: Boolean): List<DomPferd> = DatabaseFactory.dbQuery {
+        val query = HorseTable.selectAll().where { HorseTable.verantwortlichePersonId eq responsiblePersonId }
+
+        if (activeOnly) {
+            query.andWhere { HorseTable.istAktiv eq true }
+        } else {
+            query
+        }.orderBy(HorseTable.pferdeName to SortOrder.ASC)
+         .map { rowToDomPferd(it) }
+    }
+
+    override suspend fun findByGeschlecht(geschlecht: PferdeGeschlechtE, activeOnly: Boolean, limit: Int): List<DomPferd> = DatabaseFactory.dbQuery {
+        val query = HorseTable.selectAll().where { HorseTable.geschlecht eq geschlecht }
+
+        if (activeOnly) {
+            query.andWhere { HorseTable.istAktiv eq true }
+        } else {
+            query
+        }.orderBy(HorseTable.pferdeName to SortOrder.ASC)
+         .limit(limit)
+         .map { rowToDomPferd(it) }
+    }
+
+    override suspend fun findByRasse(rasse: String, activeOnly: Boolean, limit: Int): List<DomPferd> = DatabaseFactory.dbQuery {
+        val query = HorseTable.selectAll().where { HorseTable.rasse eq rasse }
+
+        if (activeOnly) {
+            query.andWhere { HorseTable.istAktiv eq true }
+        } else {
+            query
+        }.orderBy(HorseTable.pferdeName to SortOrder.ASC)
+         .limit(limit)
+         .map { rowToDomPferd(it) }
+    }
+
+    override suspend fun findByBirthYear(birthYear: Int, activeOnly: Boolean): List<DomPferd> = DatabaseFactory.dbQuery {
+        val query = HorseTable.selectAll().where {
+            HorseTable.geburtsdatum.isNotNull() and
+                (CustomFunction(
+                    "EXTRACT",
+                    IntegerColumnType(),
+                    stringLiteral("YEAR FROM "),
+                    HorseTable.geburtsdatum
+                ) eq birthYear)
+        }
+
+        if (activeOnly) {
+            query.andWhere { HorseTable.istAktiv eq true }
+        } else {
+            query
+        }.orderBy(HorseTable.pferdeName to SortOrder.ASC)
+         .map { rowToDomPferd(it) }
+    }
+
+    override suspend fun findByBirthYearRange(fromYear: Int, toYear: Int, activeOnly: Boolean): List<DomPferd> = DatabaseFactory.dbQuery {
+        val query = HorseTable.selectAll().where {
+            HorseTable.geburtsdatum.isNotNull() and
+                (CustomFunction(
+                    "EXTRACT",
+                    IntegerColumnType(),
+                    stringLiteral("YEAR FROM "),
+                    HorseTable.geburtsdatum
+                ) greaterEq fromYear) and
+                (CustomFunction(
+                    "EXTRACT",
+                    IntegerColumnType(),
+                    stringLiteral("YEAR FROM "),
+                    HorseTable.geburtsdatum
+                ) lessEq toYear)
+        }
+
+        if (activeOnly) {
+            query.andWhere { HorseTable.istAktiv eq true }
+        } else {
+            query
+        }.orderBy(HorseTable.geburtsdatum, SortOrder.DESC)
+         .map { rowToDomPferd(it) }
+    }
+
+    override suspend fun findAllActive(limit: Int): List<DomPferd> = DatabaseFactory.dbQuery {
+        HorseTable.selectAll().where { HorseTable.istAktiv eq true }
+            .orderBy(HorseTable.pferdeName to SortOrder.ASC)
+            .limit(limit)
+            .map { rowToDomPferd(it) }
+    }
+
+    override suspend fun findOepsRegistered(activeOnly: Boolean): List<DomPferd> = DatabaseFactory.dbQuery {
+        val query = HorseTable.selectAll().where { HorseTable.oepsNummer.isNotNull() }
+
+        if (activeOnly) {
+            query.andWhere { HorseTable.istAktiv eq true }
+        } else {
+            query
+        }.orderBy(HorseTable.pferdeName to SortOrder.ASC)
+         .map { rowToDomPferd(it) }
+    }
+
+    override suspend fun findFeiRegistered(activeOnly: Boolean): List<DomPferd> = DatabaseFactory.dbQuery {
+        val query = HorseTable.selectAll().where { HorseTable.feiNummer.isNotNull() }
+
+        if (activeOnly) {
+            query.andWhere { HorseTable.istAktiv eq true }
+        } else {
+            query
+        }.orderBy(HorseTable.pferdeName to SortOrder.ASC)
+         .map { rowToDomPferd(it) }
+    }
+
+    override suspend fun save(horse: DomPferd): DomPferd = DatabaseFactory.dbQuery {
+        val now = Clock.System.now()
+        val existingHorse = findById(horse.pferdId)
+
+        if (existingHorse != null) {
+            // Update existing horse
+            val updatedHorse = horse.copy(updatedAt = now)
+            HorseTable.update({ HorseTable.id eq horse.pferdId }) {
+                domPferdToStatement(it, updatedHorse)
+            }
+            updatedHorse
+        } else {
+            // Insert a new horse
+            HorseTable.insert {
+                it[id] = horse.pferdId
+                domPferdToStatement(it, horse.copy(updatedAt = now))
+            }
+            horse.copy(updatedAt = now)
+        }
+    }
+
+    override suspend fun delete(id: Uuid): Boolean = DatabaseFactory.dbQuery {
+        val deletedRows = HorseTable.deleteWhere { HorseTable.id eq id }
+        deletedRows > 0
+    }
+
+    override suspend fun existsByLebensnummer(lebensnummer: String): Boolean = DatabaseFactory.dbQuery {
+        HorseTable.selectAll().where { HorseTable.lebensnummer eq lebensnummer }
+            .count() > 0
+    }
+
+    override suspend fun existsByChipNummer(chipNummer: String): Boolean = DatabaseFactory.dbQuery {
+        HorseTable.selectAll().where { HorseTable.chipNummer eq chipNummer }
+            .count() > 0
+    }
+
+    override suspend fun existsByPassNummer(passNummer: String): Boolean = DatabaseFactory.dbQuery {
+        HorseTable.selectAll().where { HorseTable.passNummer eq passNummer }
+            .count() > 0
+    }
+
+    override suspend fun existsByOepsNummer(oepsNummer: String): Boolean = DatabaseFactory.dbQuery {
+        HorseTable.selectAll().where { HorseTable.oepsNummer eq oepsNummer }
+            .count() > 0
+    }
+
+    override suspend fun existsByFeiNummer(feiNummer: String): Boolean = DatabaseFactory.dbQuery {
+        HorseTable.selectAll().where { HorseTable.feiNummer eq feiNummer }
+            .count() > 0
+    }
+
+    override suspend fun countActive(): Long = DatabaseFactory.dbQuery {
+        HorseTable.selectAll().where { HorseTable.istAktiv eq true }
+            .count()
+    }
+
+    override suspend fun countByOwnerId(ownerId: Uuid, activeOnly: Boolean): Long = DatabaseFactory.dbQuery {
+        val query = HorseTable.selectAll().where { HorseTable.besitzerId eq ownerId }
+
+        if (activeOnly) {
+            query.andWhere { HorseTable.istAktiv eq true }
+        } else {
+            query
+        }.count()
+    }
+
+    override suspend fun countOepsRegistered(activeOnly: Boolean): Long = DatabaseFactory.dbQuery {
+        val query = HorseTable.selectAll().where {
+            HorseTable.oepsNummer.isNotNull() and (HorseTable.oepsNummer neq "")
+        }
+
+        if (activeOnly) {
+            query.andWhere { HorseTable.istAktiv eq true }
+        } else {
+            query
+        }.count()
+    }
+
+    override suspend fun countFeiRegistered(activeOnly: Boolean): Long = DatabaseFactory.dbQuery {
+        val query = HorseTable.selectAll().where {
+            HorseTable.feiNummer.isNotNull() and (HorseTable.feiNummer neq "")
+        }
+
+        if (activeOnly) {
+            query.andWhere { HorseTable.istAktiv eq true }
+        } else {
+            query
+        }.count()
+    }
+
+    /**
+     * Maps a database row to a DomPferd domain object.
+     */
+    private fun rowToDomPferd(row: ResultRow): DomPferd {
+        return DomPferd(
+            pferdId = row[HorseTable.id].value,
+            pferdeName = row[HorseTable.pferdeName],
+            geschlecht = row[HorseTable.geschlecht],
+            geburtsdatum = row[HorseTable.geburtsdatum],
+            rasse = row[HorseTable.rasse],
+            farbe = row[HorseTable.farbe],
+            besitzerId = row[HorseTable.besitzerId],
+            verantwortlichePersonId = row[HorseTable.verantwortlichePersonId],
+            zuechterName = row[HorseTable.zuechterName],
+            zuchtbuchNummer = row[HorseTable.zuchtbuchNummer],
+            lebensnummer = row[HorseTable.lebensnummer],
+            chipNummer = row[HorseTable.chipNummer],
+            passNummer = row[HorseTable.passNummer],
+            oepsNummer = row[HorseTable.oepsNummer],
+            feiNummer = row[HorseTable.feiNummer],
+            vaterName = row[HorseTable.vaterName],
+            mutterName = row[HorseTable.mutterName],
+            mutterVaterName = row[HorseTable.mutterVaterName],
+            stockmass = row[HorseTable.stockmass],
+            istAktiv = row[HorseTable.istAktiv],
+            bemerkungen = row[HorseTable.bemerkungen],
+            datenQuelle = row[HorseTable.datenQuelle],
+            createdAt = row[HorseTable.createdAt],
+            updatedAt = row[HorseTable.updatedAt]
+        )
+    }
+
+    /**
+     * Maps a DomPferd domain object to database statement values.
+     */
+    private fun domPferdToStatement(statement: UpdateBuilder<*>, horse: DomPferd) {
+        statement[HorseTable.pferdeName] = horse.pferdeName
+        statement[HorseTable.geschlecht] = horse.geschlecht
+        statement[HorseTable.geburtsdatum] = horse.geburtsdatum
+        statement[HorseTable.rasse] = horse.rasse
+        statement[HorseTable.farbe] = horse.farbe
+        statement[HorseTable.besitzerId] = horse.besitzerId
+        statement[HorseTable.verantwortlichePersonId] = horse.verantwortlichePersonId
+        statement[HorseTable.zuechterName] = horse.zuechterName
+        statement[HorseTable.zuchtbuchNummer] = horse.zuchtbuchNummer
+        statement[HorseTable.lebensnummer] = horse.lebensnummer
+        statement[HorseTable.chipNummer] = horse.chipNummer
+        statement[HorseTable.passNummer] = horse.passNummer
+        statement[HorseTable.oepsNummer] = horse.oepsNummer
+        statement[HorseTable.feiNummer] = horse.feiNummer
+        statement[HorseTable.vaterName] = horse.vaterName
+        statement[HorseTable.mutterName] = horse.mutterName
+        statement[HorseTable.mutterVaterName] = horse.mutterVaterName
+        statement[HorseTable.stockmass] = horse.stockmass
+        statement[HorseTable.istAktiv] = horse.istAktiv
+        statement[HorseTable.bemerkungen] = horse.bemerkungen
+        statement[HorseTable.datenQuelle] = horse.datenQuelle
+        statement[HorseTable.createdAt] = horse.createdAt
+        statement[HorseTable.updatedAt] = horse.updatedAt
+    }
+}

backend/services/horses/horses-infrastructure/src/main/kotlin/at/mocode/horses/infrastructure/persistence/HorseTable.kt

@@ -0,0 +1,69 @@
+package at.mocode.horses.infrastructure.persistence
+
+import at.mocode.core.domain.model.PferdeGeschlechtE
+import at.mocode.core.domain.model.DatenQuelleE
+import org.jetbrains.exposed.dao.id.UUIDTable
+import org.jetbrains.exposed.sql.kotlin.datetime.date
+import org.jetbrains.exposed.sql.kotlin.datetime.timestamp
+
+/**
+ * Database table definition for horses in the horse-registry context.
+ *
+ * This table stores all horse information including identification,
+ * ownership, breeding data, and administrative information.
+ */
+object HorseTable : UUIDTable("horses") {
+    // Basic Information
+    val pferdeName = varchar("pferde_name", 255)
+    val geschlecht = enumerationByName<PferdeGeschlechtE>("geschlecht", 20)
+    val geburtsdatum = date("geburtsdatum").nullable()
+    val rasse = varchar("rasse", 100).nullable()
+    val farbe = varchar("farbe", 100).nullable()
+
+    // Ownership and Responsibility
+    val besitzerId = uuid("besitzer_id").nullable()
+    val verantwortlichePersonId = uuid("verantwortliche_person_id").nullable()
+
+    // Breeding Information
+    val zuechterName = varchar("zuechter_name", 255).nullable()
+    val zuchtbuchNummer = varchar("zuchtbuch_nummer", 100).nullable()
+
+    // Identification Numbers
+    val lebensnummer = varchar("lebensnummer", 50).nullable()
+    val chipNummer = varchar("chip_nummer", 50).nullable()
+    val passNummer = varchar("pass_nummer", 50).nullable()
+    val oepsNummer = varchar("oeps_nummer", 50).nullable()
+    val feiNummer = varchar("fei_nummer", 50).nullable()
+
+    // Pedigree Information
+    val vaterName = varchar("vater_name", 255).nullable()
+    val mutterName = varchar("mutter_name", 255).nullable()
+    val mutterVaterName = varchar("mutter_vater_name", 255).nullable()
+
+    // Physical Characteristics
+    val stockmass = integer("stockmass").nullable()
+
+    // Status and Administrative
+    val istAktiv = bool("ist_aktiv").default(true)
+    val bemerkungen = text("bemerkungen").nullable()
+    val datenQuelle = enumerationByName<DatenQuelleE>("daten_quelle", 20).default(DatenQuelleE.MANUELL)
+
+    // Audit Fields
+    val createdAt = timestamp("created_at")
+    val updatedAt = timestamp("updated_at")
+
+    init {
+        // Indexes for performance
+        index(false, pferdeName)
+        index(false, besitzerId)
+        index(false, istAktiv)
+
+        // Unique constraints for identification numbers
+        // These ensure database-level uniqueness even under concurrent access
+        uniqueIndex(lebensnummer)
+        uniqueIndex(chipNummer)
+        uniqueIndex(passNummer)
+        uniqueIndex(oepsNummer)
+        uniqueIndex(feiNummer)
+    }
+}