feat: implement entity configuration metadata

.env

@@ -3,4 +3,4 @@ DATASOURCE_USER=openid-federation-db-user
 DATASOURCE_PASSWORD=openid-federation-db-password
 DATASOURCE_DB=openid-federation-db
 APP_KEY=Nit5tWts42QeCynT1Q476LyStDeSd4xb
-ROOT_IDENTIFIER=http://localhost:8080
+ROOT_IDENTIFIER=http://localhost:8080

modules/admin-server/build.gradle.kts

@@ -30,6 +30,7 @@ dependencies {
     testImplementation(libs.testcontainer.postgres)
     runtimeOnly(libs.postgres)
     runtimeOnly(libs.springboot.devtools)
+    implementation("io.ktor:ktor-serialization-kotlinx-json:2.3.11")
 }
 
 kotlin {

modules/admin-server/src/main/kotlin/com/sphereon/oid/fed/server/admin/controllers/EntityConfigurationMetadataController.kt

@@ -0,0 +1,39 @@
+package com.sphereon.oid.fed.server.admin.controllers
+
+import com.sphereon.oid.fed.openapi.models.CreateMetadataDTO
+import com.sphereon.oid.fed.persistence.models.EntityConfigurationMetadata
+import com.sphereon.oid.fed.services.EntityConfigurationMetadataService
+import org.springframework.web.bind.annotation.*
+
+@RestController
+@RequestMapping("/accounts/{accountUsername}/metadata")
+class EntityConfigurationMetadataController {
+    private val entityConfigurationMetadataService = EntityConfigurationMetadataService()
+
+    @GetMapping
+    fun get(
+        @PathVariable accountUsername: String
+    ): Array<EntityConfigurationMetadata> {
+        return entityConfigurationMetadataService.findByAccountUsername(accountUsername)
+    }
+
+    @PostMapping
+    fun create(
+        @PathVariable accountUsername: String,
+        @RequestBody metadata: CreateMetadataDTO
+    ): EntityConfigurationMetadata {
+        return entityConfigurationMetadataService.createEntityConfigurationMetadata(
+            accountUsername,
+            metadata.key,
+            metadata.value
+        )
+    }
+
+    @DeleteMapping("/{id}")
+    fun delete(
+        @PathVariable accountUsername: String,
+        @PathVariable id: Int
+    ): EntityConfigurationMetadata {
+        return entityConfigurationMetadataService.deleteEntityConfigurationMetadata(accountUsername, id)
+    }
+}

modules/federation-server/src/main/kotlin/com/sphereon/oid/fed/server/federation/controllers/FederationController.kt

@@ -28,7 +28,13 @@ class FederationController {
 
     @GetMapping("/{username}/.well-known/openid-federation")
     fun getAccountEntityConfigurationStatement(@PathVariable username: String): String {
-        throw NotImplementedError()
+        val account = accountQueries.findByUsername(username).executeAsOneOrNull()
+            ?: throw IllegalArgumentException("Account not found")
+        val entityConfigurationStatement =
+            entityConfigurationStatementQueries.findLatestByAccountId(account.id).executeAsOneOrNull()
+                ?: throw IllegalArgumentException("Entity Configuration Statement not found")
+
+        return entityConfigurationStatement.statement
     }
 
     @GetMapping("/list")

modules/openapi/src/commonMain/kotlin/com/sphereon/oid/fed/openapi/openapi.yaml

@@ -2488,6 +2488,21 @@ components:
         - code
         - token
 
+    CreateMetadataDTO:
+      type: object
+      properties:
+        key:
+          type: string
+          description: The metadata key.
+          example: openid_relying_party
+        value:
+          additionalProperties: true
+          description: The metadata object.
+      required:
+        - key
+        - value
+
+
     OAuthDynamicClientMetadata:
       type:
         object

modules/persistence/src/commonMain/kotlin/com/sphereon/oid/fed/persistence/Persistence.kt

@@ -1,13 +1,11 @@
 package com.sphereon.oid.fed.persistence
 
-import com.sphereon.oid.fed.persistence.models.AccountQueries
-import com.sphereon.oid.fed.persistence.models.EntityConfigurationStatementQueries
-import com.sphereon.oid.fed.persistence.models.KeyQueries
-import com.sphereon.oid.fed.persistence.models.SubordinateQueries
+import com.sphereon.oid.fed.persistence.models.*
 
 expect object Persistence {
     val entityConfigurationStatementQueries: EntityConfigurationStatementQueries
     val accountQueries: AccountQueries
     val keyQueries: KeyQueries
     val subordinateQueries: SubordinateQueries
+    val entityConfigurationMetadataQueries: EntityConfigurationMetadataQueries
 }

modules/persistence/src/commonMain/sqldelight/com/sphereon/oid/fed/persistence/models/4.sqm

@@ -7,4 +7,4 @@ CREATE TABLE entityConfigurationStatement (
     CONSTRAINT FK_ParentEntityConfigurationStatement FOREIGN KEY (account_id) REFERENCES account (id)
 );
 
-CREATE INDEX entity_statement_account_id_index ON subordinate (account_id);
+CREATE INDEX entity_configuraion_statement_account_id_index ON subordinate (account_id);

modules/persistence/src/commonMain/sqldelight/com/sphereon/oid/fed/persistence/models/5.sqm

@@ -0,0 +1,11 @@
+CREATE TABLE entityConfigurationMetadata (
+    id SERIAL PRIMARY KEY,
+    account_id INT NOT NULL,
+    key TEXT NOT NULL,
+    value TEXT NOT NULL,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    deleted_at TIMESTAMP,
+    CONSTRAINT FK_ParentEntityConfigurationMetadata FOREIGN KEY (account_id) REFERENCES account (id)
+);
+
+CREATE INDEX entity_configuration_metadata_account_id_index ON subordinate (account_id);

modules/persistence/src/commonMain/sqldelight/com/sphereon/oid/fed/persistence/models/EntityConfigurationMetadata.sq

@@ -0,0 +1,18 @@
+create:
+INSERT INTO entityConfigurationMetadata (
+    account_id,
+    key,
+    value
+) VALUES (?, ?, ?) RETURNING *;
+
+delete:
+UPDATE entityConfigurationMetadata SET deleted_at = CURRENT_TIMESTAMP WHERE id = ? AND deleted_at IS NULL RETURNING *;
+
+findByAccountId:
+SELECT * FROM entityConfigurationMetadata WHERE account_id = ? AND deleted_at IS NULL;
+
+findByAccountIdAndKey:
+SELECT * FROM entityConfigurationMetadata WHERE account_id = ? AND key = ? AND deleted_at IS NULL;
+
+findById:
+SELECT * FROM entityConfigurationMetadata WHERE id = ? AND deleted_at IS NULL;

modules/persistence/src/jvmMain/kotlin/com.sphereon.oid.fed.persistence/Persistence.jvm.kt

@@ -4,16 +4,14 @@ import app.cash.sqldelight.db.QueryResult
 import app.cash.sqldelight.db.SqlCursor
 import app.cash.sqldelight.db.SqlDriver
 import com.sphereon.oid.fed.persistence.database.PlatformSqlDriver
-import com.sphereon.oid.fed.persistence.models.AccountQueries
-import com.sphereon.oid.fed.persistence.models.EntityConfigurationStatementQueries
-import com.sphereon.oid.fed.persistence.models.KeyQueries
-import com.sphereon.oid.fed.persistence.models.SubordinateQueries
+import com.sphereon.oid.fed.persistence.models.*
 
 actual object Persistence {
     actual val entityConfigurationStatementQueries: EntityConfigurationStatementQueries
     actual val accountQueries: AccountQueries
     actual val keyQueries: KeyQueries
     actual val subordinateQueries: SubordinateQueries
+    actual val entityConfigurationMetadataQueries: EntityConfigurationMetadataQueries
 
     init {
         val driver = getDriver()
@@ -24,6 +22,7 @@ actual object Persistence {
         entityConfigurationStatementQueries = database.entityConfigurationStatementQueries
         keyQueries = database.keyQueries
         subordinateQueries = database.subordinateQueries
+        entityConfigurationMetadataQueries = database.entityConfigurationMetadataQueries
     }
 
     private fun getDriver(): SqlDriver {

modules/services/src/commonMain/kotlin/com/sphereon/oid/fed/services/EntityConfigurationMetadataService.kt

@@ -0,0 +1,53 @@
+package com.sphereon.oid.fed.services
+
+import com.sphereon.oid.fed.persistence.Persistence
+import com.sphereon.oid.fed.persistence.models.EntityConfigurationMetadata
+import kotlinx.serialization.json.JsonObject
+
+class EntityConfigurationMetadataService {
+    fun createEntityConfigurationMetadata(
+        accountUsername: String,
+        key: String,
+        metadata: JsonObject
+    ): EntityConfigurationMetadata {
+        val account = Persistence.accountQueries.findByUsername(accountUsername).executeAsOneOrNull()
+            ?: throw IllegalArgumentException("Account not found")
+
+        val metadataAlreadyExists =
+            Persistence.entityConfigurationMetadataQueries.findByAccountIdAndKey(account.id, key).executeAsOneOrNull()
+
+        if (metadataAlreadyExists != null) {
+            throw IllegalStateException("Entity configuration metadata already exists")
+        }
+
+        return Persistence.entityConfigurationMetadataQueries.create(account.id, key, metadata.toString())
+            .executeAsOneOrNull()
+            ?: throw IllegalStateException("Failed to create entity configuration metadata")
+    }
+
+    fun findByAccountId(accountId: Int): Array<EntityConfigurationMetadata> {
+        return Persistence.entityConfigurationMetadataQueries.findByAccountId(accountId).executeAsList().toTypedArray()
+    }
+
+    fun findByAccountUsername(accountUsername: String): Array<EntityConfigurationMetadata> {
+        val account = Persistence.accountQueries.findByUsername(accountUsername).executeAsOneOrNull()
+            ?: throw IllegalArgumentException("Account not found")
+        return Persistence.entityConfigurationMetadataQueries.findByAccountId(account.id).executeAsList().toTypedArray()
+    }
+
+    fun deleteEntityConfigurationMetadata(accountUsername: String, id: Int): EntityConfigurationMetadata {
+        val account = Persistence.accountQueries.findByUsername(accountUsername).executeAsOneOrNull()
+            ?: throw IllegalArgumentException("Account not found")
+
+        val metadata =
+            Persistence.entityConfigurationMetadataQueries.findById(id).executeAsOneOrNull()
+                ?: throw IllegalArgumentException("Entity configuration metadata not found")
+
+        if (metadata.account_id != account.id) {
+            throw IllegalArgumentException("Entity configuration metadata not found")
+        }
+
+        return Persistence.entityConfigurationMetadataQueries.delete(id).executeAsOneOrNull()
+            ?: throw IllegalArgumentException("Entity configuration metadata not found")
+    }
+}

modules/services/src/commonMain/kotlin/com/sphereon/oid/fed/services/EntityStatementService.kt

@@ -45,6 +45,14 @@ class EntityStatementService {
             )
         }
 
+        val metadata = Persistence.entityConfigurationMetadataQueries.findByAccountId(account.id).executeAsList()
+
+        metadata.forEach {
+            entityConfigurationStatement.metadata(
+                Pair(it.key, Json.parseToJsonElement(it.value_).jsonObject)
+            )
+        }
+
         return entityConfigurationStatement.build()
     }