From 37b2629ec686ea2e9bf19d3202e5fa6c4efb0aad Mon Sep 17 00:00:00 2001
From: Rens Pols <rens@cepols.nl>
Date: Tue, 7 Oct 2025 22:52:12 +0200
Subject: [PATCH 01/45] refactor: Moved the getScope eventbus functions to
 their own file

---
 .../database/scope/ScopeJdbcVerticle.kt       | 50 ++-----------------
 .../ex_dock/database/scope/getScopes.kt       | 50 +++++++++++++++++++
 2 files changed, 54 insertions(+), 46 deletions(-)
 create mode 100644 src/main/kotlin/com/ex_dock/ex_dock/database/scope/getScopes.kt

diff --git a/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt b/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt
index a31454c0..2f2a5d91 100644
--- a/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt
+++ b/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt
@@ -25,10 +25,10 @@ class ScopeJdbcVerticle:  VerticleBase() {
     eventBus = vertx.eventBus()
 
     // Initialize all eventbus connections for basic scopes
-    getAllScopes()
-    getScopeById()
-    getScopesByWebsiteName()
-    getScopesByStoreViewName()
+    eventBus.getAllScopes(client)
+    eventBus.getScopeById(client)
+    eventBus.getScopesByWebsiteName(client)
+    eventBus.getScopesByStoreViewName(client)
     createScope()
     editScope()
     deleteScope()
@@ -36,48 +36,6 @@ class ScopeJdbcVerticle:  VerticleBase() {
     return Future.succeededFuture<Unit>()
   }
 
-  private fun getAllScopes() {
-    val getAllScopesConsumer = eventBus.consumer<String>("process.scope.getAllScopes")
-    getAllScopesConsumer.handler { message ->
-      val query = JsonObject()
-
-      client.find("scopes", query).replyListMessage(message)
-    }
-  }
-
-  private fun getScopeById() {
-    val getScopeByWebsiteIdConsumer = eventBus.consumer<String>("process.scope.getScopeByWebsiteId")
-    getScopeByWebsiteIdConsumer.handler { message ->
-      val websiteId = message.body()
-      val query = JsonObject()
-        .put("_id", websiteId)
-
-      client.find("scopes", query).replySingleMessage(message)
-    }
-  }
-
-  private fun getScopesByWebsiteName() {
-    val getScopesByWebsiteNameConsumer = eventBus.consumer<String>("process.scope.getScopesByWebsiteName")
-    getScopesByWebsiteNameConsumer.handler { message ->
-      val websiteName = message.body()
-      val query = JsonObject()
-        .put("website_name", websiteName)
-
-      client.find("scopes", query).replyListMessage(message)
-    }
-  }
-
-  private fun getScopesByStoreViewName() {
-    val getScopesByStoreViewNameConsumer = eventBus.consumer<String>("process.scope.getScopesByStoreViewName")
-    getScopesByStoreViewNameConsumer.handler { message ->
-      val storeViewName = message.body()
-      val query = JsonObject()
-        .put("store_view_name", storeViewName)
-
-      client.find("scopes", query).replyListMessage(message)
-    }
-  }
-
   private fun createScope() {
     val createScopeConsumer = eventBus.consumer<Scope>("process.scope.createScope")
     createScopeConsumer.handler { message ->
diff --git a/src/main/kotlin/com/ex_dock/ex_dock/database/scope/getScopes.kt b/src/main/kotlin/com/ex_dock/ex_dock/database/scope/getScopes.kt
new file mode 100644
index 00000000..f0a40cc9
--- /dev/null
+++ b/src/main/kotlin/com/ex_dock/ex_dock/database/scope/getScopes.kt
@@ -0,0 +1,50 @@
+package com.ex_dock.ex_dock.database.scope
+
+import com.ex_dock.ex_dock.helper.replyListMessage
+import com.ex_dock.ex_dock.helper.replySingleMessage
+import io.vertx.core.eventbus.EventBus
+import io.vertx.core.json.JsonObject
+import io.vertx.ext.mongo.MongoClient
+
+
+internal fun EventBus.getAllScopes(client: MongoClient) {
+  val getAllScopesConsumer = this.consumer<String>("process.scope.getAllScopes")
+  getAllScopesConsumer.handler { message ->
+    val query = JsonObject()
+
+    client.find("scopes", query).replyListMessage(message)
+  }
+}
+
+internal fun EventBus.getScopeById(client: MongoClient) {
+  val getScopeByWebsiteIdConsumer = this.consumer<String>("process.scope.getScopeByWebsiteId")
+  getScopeByWebsiteIdConsumer.handler { message ->
+    val websiteId = message.body()
+    val query = JsonObject()
+      .put("_id", websiteId)
+
+    client.find("scopes", query).replySingleMessage(message)
+  }
+}
+
+internal fun EventBus.getScopesByWebsiteName(client: MongoClient) {
+  val getScopesByWebsiteNameConsumer = this.consumer<String>("process.scope.getScopesByWebsiteName")
+  getScopesByWebsiteNameConsumer.handler { message ->
+    val websiteName = message.body()
+    val query = JsonObject()
+      .put("website_name", websiteName)
+
+    client.find("scopes", query).replyListMessage(message)
+  }
+}
+
+internal fun EventBus.getScopesByStoreViewName(client: MongoClient) {
+  val getScopesByStoreViewNameConsumer = this.consumer<String>("process.scope.getScopesByStoreViewName")
+  getScopesByStoreViewNameConsumer.handler { message ->
+    val storeViewName = message.body()
+    val query = JsonObject()
+      .put("store_view_name", storeViewName)
+
+    client.find("scopes", query).replyListMessage(message)
+  }
+}

From 234506091e27d11412bafef41916aa2ccf816272 Mon Sep 17 00:00:00 2001
From: Rens Pols <rens@cepols.nl>
Date: Tue, 7 Oct 2025 23:22:26 +0200
Subject: [PATCH 02/45] feat(core): Add error response helper

Adds `errorResponse` extension functions to `Message`
for simplified error handling in Vert.x event bus.
This allows sending standardized error responses with
failure codes and messages.
---
 .../helper/messages/messageErrorResponse.kt    | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 src/main/kotlin/com/ex_dock/ex_dock/helper/messages/messageErrorResponse.kt

diff --git a/src/main/kotlin/com/ex_dock/ex_dock/helper/messages/messageErrorResponse.kt b/src/main/kotlin/com/ex_dock/ex_dock/helper/messages/messageErrorResponse.kt
new file mode 100644
index 00000000..aeeec000
--- /dev/null
+++ b/src/main/kotlin/com/ex_dock/ex_dock/helper/messages/messageErrorResponse.kt
@@ -0,0 +1,18 @@
+package com.ex_dock.ex_dock.helper.messages
+
+import com.ex_dock.ex_dock.MainVerticle
+import com.ex_dock.ex_dock.helper.errors.failureCode
+import io.vertx.core.eventbus.Message
+
+fun Message<*>.errorResponse(throwable: Throwable) {
+  this.errorResponse(throwable.failureCode(), throwable)
+}
+
+fun Message<*>.errorResponse(failureCode: Int, throwable: Throwable) {
+  this.errorResponse(failureCode, throwable.message ?: "Missing throwable error message")
+}
+
+fun Message<*>.errorResponse(failureCode: Int, message: String) {
+  MainVerticle.logger.error { "message.errorResponse() [${failureCode}] $message" }
+  this.fail(failureCode, message)
+}

From 0ccccd1e7bc17e24a0a0e530bc8264264629c759 Mon Sep 17 00:00:00 2001
From: Rens Pols <rens@cepols.nl>
Date: Tue, 7 Oct 2025 23:40:54 +0200
Subject: [PATCH 03/45] feat(scope): Add scope creation endpoints

Adds website and store-view creation via event bus.
Replaces old createScope method.
Uses `createScopes.kt` for new functions.
Complexity is medium.
---
 .../database/scope/ScopeJdbcVerticle.kt       | 29 +-------
 .../ex_dock/database/scope/createScopes.kt    | 74 +++++++++++++++++++
 2 files changed, 76 insertions(+), 27 deletions(-)
 create mode 100644 src/main/kotlin/com/ex_dock/ex_dock/database/scope/createScopes.kt

diff --git a/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt b/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt
index 2f2a5d91..30fae1f8 100644
--- a/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt
+++ b/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt
@@ -29,39 +29,14 @@ class ScopeJdbcVerticle:  VerticleBase() {
     eventBus.getScopeById(client)
     eventBus.getScopesByWebsiteName(client)
     eventBus.getScopesByStoreViewName(client)
-    createScope()
+    eventBus.createWebsite(client)
+    eventBus.createStoreView(client)
     editScope()
     deleteScope()
 
     return Future.succeededFuture<Unit>()
   }
 
-  private fun createScope() {
-    val createScopeConsumer = eventBus.consumer<Scope>("process.scope.createScope")
-    createScopeConsumer.handler { message ->
-      println("Received createScope message in ScopeJdbcVerticle")
-      val scope = message.body()
-      val document = scope.toDocument()
-
-      val rowsFuture = client.save("scopes", document)
-
-      rowsFuture.onFailure { res ->
-        println("Failed to execute query: $res")
-        message.fail(500, "Failed to execute query: $res")
-      }
-
-      rowsFuture.onSuccess { res ->
-        val lastInsertID: String? = res
-        if (lastInsertID != null) {
-          scope.scopeId = lastInsertID
-        }
-
-        setCacheFlag(eventBus, CACHE_ADDRESS)
-        message.reply(scope, fullScopeDeliveryOptions)
-      }
-    }
-  }
-
   private fun editScope() {
     val editScopeConsumer = eventBus.consumer<Scope>("process.scope.editScope")
     editScopeConsumer.handler { message ->
diff --git a/src/main/kotlin/com/ex_dock/ex_dock/database/scope/createScopes.kt b/src/main/kotlin/com/ex_dock/ex_dock/database/scope/createScopes.kt
new file mode 100644
index 00000000..b67a0c72
--- /dev/null
+++ b/src/main/kotlin/com/ex_dock/ex_dock/database/scope/createScopes.kt
@@ -0,0 +1,74 @@
+package com.ex_dock.ex_dock.database.scope
+
+import com.ex_dock.ex_dock.helper.messages.errorResponse
+import io.vertx.core.eventbus.EventBus
+import io.vertx.core.json.JsonObject
+import io.vertx.ext.mongo.MongoClient
+
+internal fun EventBus.createWebsite(client: MongoClient) {
+  this.localConsumer<JsonObject>("process.scope.create.website").handler { message ->
+    val data = message.body()
+
+    if (data.getString("_id") != null)
+      return@handler message.fail(400, "This function is for creating websites (scope), not editing them.")
+
+    val name = data.getString("scopeName")
+      ?: return@handler message.fail(400, "The name of the website (scope) is required.")
+    val key = data.getString("scopeKey")
+      ?: return@handler message.fail(400, "The key of the website (scope) is required.")
+
+    val document = JsonObject()
+      .put("scopeName", name)
+      .put("scopKey", key)
+      .put("scopeType", "website")
+
+    client.insert("scopes", document).onFailure { err ->
+      message.errorResponse(err)
+    }.onSuccess { res ->
+      message.reply(res)
+    }
+  }
+}
+
+internal fun EventBus.createStoreView(client: MongoClient) {
+  this.localConsumer<JsonObject>("process.scope.create.store-view").handler { message ->
+    val data = message.body()
+
+    if (data.getString("_id") != null)
+      return@handler message.fail(400, "This function is for creating store-views (scope), not editing them.")
+
+    val name = data.getString("name")
+      ?: return@handler message.fail(400, "The name of the store-view (scope) is required.")
+    val key = data.getString("key")
+      ?: return@handler message.fail(400, "The key of the store-view (scope) is required.")
+    val websiteId = data.getString("websiteId")
+      ?: return@handler message.fail(400, "The websiteId of the parent website (scope) is required.")
+
+    val searchWebsiteQuery = JsonObject().put("scopeType", "website").put("_id", websiteId)
+    client.find("scopes", searchWebsiteQuery).onFailure { err ->
+      message.errorResponse(err)
+    }.onSuccess { res ->
+      if (res.isEmpty())
+        return@onSuccess message.fail(400, "The websiteId of the parent website (scope) does not exist")
+
+      client.find("scopes", JsonObject().put("scopKey", key)).onFailure { err ->
+        message.errorResponse(err)
+      }.onSuccess { res ->
+        if (res.isNotEmpty())
+          return@onSuccess message.fail(400, "The key of the store-view (scope) already exists for a scope")
+
+        val document = JsonObject()
+          .put("scopeName", name)
+          .put("scopKey", key)
+          .put("scopeType", "store-view")
+          .put("websiteId", websiteId)
+
+        client.insert("scopes", document).onFailure { err ->
+          message.errorResponse(err)
+        }.onSuccess { res ->
+          message.reply(res)
+        }
+      }
+    }
+  }
+}

From dfed4558db0cadffe1d02d7ba40a32897a808a45 Mon Sep 17 00:00:00 2001
From: Rens Pols <rens@cepols.nl>
Date: Tue, 7 Oct 2025 23:43:38 +0200
Subject: [PATCH 04/45] refactor(database): Add TODOs for editScope

The comment indicates a need for stricter
editScope functions and deprecation of the
global one.
---
 .../com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt     | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt b/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt
index 30fae1f8..9ee0f8eb 100644
--- a/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt
+++ b/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt
@@ -38,6 +38,7 @@ class ScopeJdbcVerticle:  VerticleBase() {
   }
 
   private fun editScope() {
+    // TODO: implement strict editScope functions and deprecate this global one
     val editScopeConsumer = eventBus.consumer<Scope>("process.scope.editScope")
     editScopeConsumer.handler { message ->
       val body = message.body()
@@ -66,6 +67,7 @@ class ScopeJdbcVerticle:  VerticleBase() {
   }
 
   private fun deleteScope() {
+    // TODO: remove all data associated with the scope
     val deleteScopeConsumer = eventBus.consumer<String>("process.scope.deleteScope")
     deleteScopeConsumer.handler { message ->
       val scopeId = message.body()

From 2b6317b26c7ab8c30e15d93060bfcc30cc76ac84 Mon Sep 17 00:00:00 2001
From: Rens Pols <rens@cepols.nl>
Date: Tue, 7 Oct 2025 23:45:04 +0200
Subject: [PATCH 05/45] refactor(scope): Use constant for cache address

Replaces hardcoded string "scopes" with ScopeJdbcVerticle.CACHE_ADDRESS to improve maintainability and reduce potential errors.
---
 .../ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt   | 2 +-
 .../com/ex_dock/ex_dock/database/scope/createScopes.kt    | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt b/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt
index 9ee0f8eb..5b747957 100644
--- a/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt
+++ b/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt
@@ -17,7 +17,7 @@ class ScopeJdbcVerticle:  VerticleBase() {
   private val fullScopeDeliveryOptions: DeliveryOptions = DeliveryOptions().setCodecName("ScopeCodec")
 
   companion object {
-    private const val CACHE_ADDRESS = "scopes"
+    const val CACHE_ADDRESS = "scopes"
   }
 
   override fun start(): Future<*>? {
diff --git a/src/main/kotlin/com/ex_dock/ex_dock/database/scope/createScopes.kt b/src/main/kotlin/com/ex_dock/ex_dock/database/scope/createScopes.kt
index b67a0c72..70ba2235 100644
--- a/src/main/kotlin/com/ex_dock/ex_dock/database/scope/createScopes.kt
+++ b/src/main/kotlin/com/ex_dock/ex_dock/database/scope/createScopes.kt
@@ -22,7 +22,7 @@ internal fun EventBus.createWebsite(client: MongoClient) {
       .put("scopKey", key)
       .put("scopeType", "website")
 
-    client.insert("scopes", document).onFailure { err ->
+    client.insert(ScopeJdbcVerticle.CACHE_ADDRESS, document).onFailure { err ->
       message.errorResponse(err)
     }.onSuccess { res ->
       message.reply(res)
@@ -45,13 +45,13 @@ internal fun EventBus.createStoreView(client: MongoClient) {
       ?: return@handler message.fail(400, "The websiteId of the parent website (scope) is required.")
 
     val searchWebsiteQuery = JsonObject().put("scopeType", "website").put("_id", websiteId)
-    client.find("scopes", searchWebsiteQuery).onFailure { err ->
+    client.find(ScopeJdbcVerticle.CACHE_ADDRESS, searchWebsiteQuery).onFailure { err ->
       message.errorResponse(err)
     }.onSuccess { res ->
       if (res.isEmpty())
         return@onSuccess message.fail(400, "The websiteId of the parent website (scope) does not exist")
 
-      client.find("scopes", JsonObject().put("scopKey", key)).onFailure { err ->
+      client.find(ScopeJdbcVerticle.CACHE_ADDRESS, JsonObject().put("scopKey", key)).onFailure { err ->
         message.errorResponse(err)
       }.onSuccess { res ->
         if (res.isNotEmpty())
@@ -63,7 +63,7 @@ internal fun EventBus.createStoreView(client: MongoClient) {
           .put("scopeType", "store-view")
           .put("websiteId", websiteId)
 
-        client.insert("scopes", document).onFailure { err ->
+        client.insert(ScopeJdbcVerticle.CACHE_ADDRESS, document).onFailure { err ->
           message.errorResponse(err)
         }.onSuccess { res ->
           message.reply(res)

From 086c692ea598c29139cca338448017bf283bca30 Mon Sep 17 00:00:00 2001
From: Rens Pols <rens@cepols.nl>
Date: Wed, 8 Oct 2025 00:47:54 +0200
Subject: [PATCH 06/45] Refactor(scope): Refactor scope tests

Refactors scope tests to use JsonObject.
The Scope data class is deprecated.
---
 .../ex_dock/database/scope/ScopeClasses.kt    |   1 +
 .../database/scope/ScopeJdbcVerticleTest.kt   | 204 +++++++++++-------
 2 files changed, 126 insertions(+), 79 deletions(-)

diff --git a/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeClasses.kt b/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeClasses.kt
index 371fa491..daff8254 100644
--- a/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeClasses.kt
+++ b/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeClasses.kt
@@ -2,6 +2,7 @@ package com.ex_dock.ex_dock.database.scope
 
 import io.vertx.core.json.JsonObject
 
+@Deprecated("Scope() is deprecated, use JsonObject instead")
 data class Scope(
   var scopeId: String?,
   var websiteName: String,
diff --git a/src/test/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticleTest.kt b/src/test/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticleTest.kt
index 97101a91..c5a737c7 100644
--- a/src/test/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticleTest.kt
+++ b/src/test/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticleTest.kt
@@ -1,60 +1,35 @@
 package com.ex_dock.ex_dock.database.scope
 
-import com.ex_dock.ex_dock.helper.deployWorkerVerticleHelper
 import com.ex_dock.ex_dock.helper.codecs.registerGenericCodec
+import com.ex_dock.ex_dock.helper.deployWorkerVerticleHelper
 import io.vertx.core.Vertx
-import io.vertx.core.eventbus.DeliveryOptions
 import io.vertx.core.eventbus.EventBus
+import io.vertx.core.json.JsonArray
 import io.vertx.core.json.JsonObject
-import io.vertx.ext.unit.TestSuite
 import io.vertx.junit5.VertxExtension
 import io.vertx.junit5.VertxTestContext
-import org.junit.jupiter.api.AfterEach
-import org.junit.jupiter.api.BeforeEach
-import org.junit.jupiter.api.DisplayName
-import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.*
 import org.junit.jupiter.api.extension.ExtendWith
 
 @ExtendWith(VertxExtension::class)
+@TestMethodOrder(MethodOrderer.OrderAnnotation::class)
 class ScopeJdbcVerticleTest {
+
   private lateinit var eventBus: EventBus
-  private val scopeDeliveryOptions = DeliveryOptions().setCodecName("ScopeCodec")
-  private var testScope = Scope(
-    scopeId = "123",
-    websiteName = "testWebsite",
-    storeViewName = "testStoreView"
-  )
+  private val idsToCleanup = mutableListOf<String>()
 
-  @Test
-  @DisplayName("Test the scope classes functions")
-  fun testScopeClassesFunctions(vertx: Vertx, context: VertxTestContext) {
-    val suite = TestSuite.create("testScopeClassesFunctions")
-
-    suite.test("testScopeToJson") { testContext ->
-      val result = testScope.toDocument()
-      testContext.assertEquals(testScope.scopeId, result.getString("_id"))
-      testContext.assertEquals(testScope.websiteName, result.getString("website_name"))
-    }.test("testScopeFromJson") { testContext ->
-      val scopeJson = testScope.toDocument()
-      val scope = Scope.fromJson(scopeJson)
-      testContext.assertEquals(testScope.scopeId, scope.scopeId)
-      testContext.assertEquals(testScope.websiteName, scope.websiteName)
-    }
+  // Test data
+  private val websiteJson = JsonObject()
+    .put("scopeName", "Test Website")
+    .put("scopeKey", "test_website")
 
-    suite.run(vertx).handler { res ->
-      if (res.succeeded()) {
-        context.completeNow()
-      } else {
-        context.failNow(res.cause())
-      }
-    }
-  }
+  private lateinit var testWebsiteId: String
 
   @BeforeEach
-  @DisplayName("Add the scope to the database")
-  fun setup(vertx: Vertx, vertxTestContext: VertxTestContext) {
+  @DisplayName("Deploy Verticle and Create a Base Website Scope")
+  fun setup(vertx: Vertx, context: VertxTestContext) {
     eventBus = vertx.eventBus()
-    eventBus.registerGenericCodec(Scope::class)
+    // The List codec is still needed for functions that return multiple results
     eventBus.registerGenericCodec(List::class)
 
     deployWorkerVerticleHelper(
@@ -63,64 +38,135 @@ class ScopeJdbcVerticleTest {
       1,
       1
     ).onFailure { err ->
-      vertxTestContext.failNow(err)
+      context.failNow(err)
     }.onSuccess {
-      eventBus.request<Scope>("process.scope.createScope", testScope, scopeDeliveryOptions).onFailure {
-        vertxTestContext.failNow(it)
+      // Create a base website for other tests to use
+      eventBus.request<String>("process.scope.create.website", websiteJson).onFailure {
+        context.failNow(it)
       }.onSuccess { message ->
-        val result = message.body()
-        testScope.scopeId = result.scopeId // Update testScope with the generated ID
-        vertxTestContext.verify { ->
-          assert(result.scopeId != null)
-          assert(result.websiteName == testScope.websiteName)
-          assert(result.storeViewName == testScope.storeViewName)
-          vertxTestContext.completeNow()
-        }
+        testWebsiteId = message.body()
+        idsToCleanup.add(testWebsiteId) // Ensure it gets cleaned up
+        context.completeNow()
+      }
+    }
+  }
+
+  @AfterEach
+  @DisplayName("Remove Scopes from the Database")
+  fun tearDown(vertx: Vertx, context: VertxTestContext) {
+    val checkpoint = context.checkpoint(idsToCleanup.size)
+    if (idsToCleanup.isEmpty()) {
+      context.completeNow()
+      return
+    }
+
+    idsToCleanup.forEach { scopeId ->
+      eventBus.request<String>("process.scope.deleteScope", scopeId).onComplete {
+        checkpoint.flag()
       }
     }
   }
 
   @Test
-  @DisplayName("Test getting a scope by id from the database")
-  fun testGetScopeById(vertx: Vertx, vertxTestContext: VertxTestContext) {
-    eventBus.request<JsonObject>("process.scope.getScopeByWebsiteId", testScope.scopeId).onFailure {
-        vertxTestContext.failNow(it)
-      }.onSuccess { message ->
-        val result = Scope.fromJson(message.body())
-        vertxTestContext.verify { ->
-          assert(result.scopeId == testScope.scopeId)
-          assert(result.websiteName == testScope.websiteName)
-          assert(result.storeViewName == testScope.storeViewName)
-          vertxTestContext.completeNow()
-        }
+  @Order(1)
+  @DisplayName("Test creating a valid website scope")
+  fun testCreateWebsite(context: VertxTestContext) {
+    val newWebsite = JsonObject()
+      .put("scopeName", "Another Website")
+      .put("scopeKey", "another_website")
+
+    eventBus.request<String>("process.scope.create.website", newWebsite).onFailure {
+      context.failNow(it)
+    }.onSuccess { message ->
+      val newId = message.body()
+      context.verify {
+        Assertions.assertNotNull(newId)
       }
+      idsToCleanup.add(newId) // Add for cleanup
+      context.completeNow()
+    }
+  }
+
+  @Test
+  @Order(2)
+  @DisplayName("Test creating a valid store-view scope")
+  fun testCreateStoreView(context: VertxTestContext) {
+    val storeViewJson = JsonObject()
+      .put("name", "Test Store View")
+      .put("key", "test_store_view")
+      .put("websiteId", testWebsiteId)
+
+    eventBus.request<String>("process.scope.create.store-view", storeViewJson).onFailure {
+      context.failNow(it)
+    }.onSuccess { message ->
+      val newId = message.body()
+      context.verify {
+        Assertions.assertNotNull(newId)
+      }
+      idsToCleanup.add(newId)
+      context.completeNow()
+    }
+  }
+
+  @Test
+  @Order(3)
+  @DisplayName("Test creating a store-view with a non-existent websiteId fails")
+  fun testCreateStoreViewWithInvalidWebsiteId(context: VertxTestContext) {
+    val storeViewJson = JsonObject()
+      .put("name", "Invalid Store View")
+      .put("key", "invalid_store_view")
+      .put("websiteId", "nonExistentId123")
+
+    eventBus.request<String>("process.scope.create.store-view", storeViewJson).onSuccess {
+      context.failNow("Should have failed for invalid websiteId")
+    }.onFailure {
+      context.verify {
+        Assertions.assertTrue(it.message?.contains("does not exist") ?: false)
+        context.completeNow()
+      }
+    }
   }
 
   @Test
-  @DisplayName("Test updating a scope in the database")
-  fun testUpdateScope(vertx: Vertx, vertxTestContext: VertxTestContext) {
-    val updatedScope = testScope.copy(websiteName = "updatedWebsite")
-    eventBus.request<Scope>("process.scope.editScope", updatedScope, scopeDeliveryOptions).onFailure {
-      vertxTestContext.failNow(it)
+  @Order(4)
+  @DisplayName("Test getting a scope by its ID")
+  fun testGetScopeById(context: VertxTestContext) {
+    eventBus.request<JsonObject>("process.scope.getScopeByWebsiteId", testWebsiteId).onFailure {
+      context.failNow(it)
     }.onSuccess { message ->
       val result = message.body()
-      vertxTestContext.verify { ->
-        assert(result.websiteName == updatedScope.websiteName)
-        vertxTestContext.completeNow()
+      context.verify {
+        Assertions.assertEquals(testWebsiteId, result.getString("_id"))
+        Assertions.assertEquals(websiteJson.getString("scopeName"), result.getString("scopeName"))
+        Assertions.assertEquals("website", result.getString("scopeType"))
+        context.completeNow()
       }
     }
   }
 
-  @AfterEach
-  @DisplayName("Remove the scope from the database")
-  fun tearDown(vertx: Vertx, vertxTestContext: VertxTestContext) {
-    eventBus.request<String>("process.scope.deleteScope", testScope.scopeId).onFailure {
-      vertxTestContext.failNow(it)
+  @Test
+  @Order(5)
+  @DisplayName("Test getting all scopes")
+  fun testGetAllScopes(context: VertxTestContext) {
+    eventBus.request<List<JsonObject>>("process.scope.getAllScopes", null).onFailure {
+      context.failNow(it)
     }.onSuccess { message ->
-      vertxTestContext.verify { ->
-        assert(message.body() == "Scope deleted successfully")
-        vertxTestContext.completeNow()
+      val results = message.body()
+      results.size
+      context.verify {
+        // At least the website from setup should be present
+        Assertions.assertTrue(results.isNotEmpty())
+        val firstResult = results[0]
+        Assertions.assertNotNull(firstResult.getString("_id"))
+        context.completeNow()
       }
     }
   }
-}
+
+  /*
+   * NOTE: A test for 'editScope' has been omitted.
+   * The `editScope` function in `ScopeJdbcVerticle` has not yet been refactored.
+   * It still expects a `Scope` object, which is deprecated.
+   * A new test should be written once `editScope` is updated to work with JsonObject payloads.
+   */
+}
\ No newline at end of file

From 64ca1b3c6eaefd35cd3502dd758852a8dee09c3d Mon Sep 17 00:00:00 2001
From: Rens Pols <rens@cepols.nl>
Date: Wed, 8 Oct 2025 13:43:44 +0200
Subject: [PATCH 07/45] feat(core): Add ScopeLevel enum

Adds ScopeLevel enum with GLOBAL, WEBSITE, and STORE_VIEW values.
---
 .../kotlin/com/ex_dock/ex_dock/helper/scopes/ScopeLevel.kt | 7 +++++++
 1 file changed, 7 insertions(+)
 create mode 100644 src/main/kotlin/com/ex_dock/ex_dock/helper/scopes/ScopeLevel.kt

diff --git a/src/main/kotlin/com/ex_dock/ex_dock/helper/scopes/ScopeLevel.kt b/src/main/kotlin/com/ex_dock/ex_dock/helper/scopes/ScopeLevel.kt
new file mode 100644
index 00000000..0ed5e4da
--- /dev/null
+++ b/src/main/kotlin/com/ex_dock/ex_dock/helper/scopes/ScopeLevel.kt
@@ -0,0 +1,7 @@
+package com.ex_dock.ex_dock.helper.scopes
+
+enum class ScopeLevel {
+  GLOBAL,
+  WEBSITE,
+  STORE_VIEW;
+}
\ No newline at end of file

From f6a035a13d53c1000267e3be97f83d008e428e16 Mon Sep 17 00:00:00 2001
From: Rens Pols <rens@cepols.nl>
Date: Fri, 10 Oct 2025 22:46:26 +0200
Subject: [PATCH 08/45] Convert "scopeKey" to "_id"

---
 .../ex_dock/database/scope/createScopes.kt    | 80 +++++++++++--------
 1 file changed, 48 insertions(+), 32 deletions(-)

diff --git a/src/main/kotlin/com/ex_dock/ex_dock/database/scope/createScopes.kt b/src/main/kotlin/com/ex_dock/ex_dock/database/scope/createScopes.kt
index 70ba2235..2af150d8 100644
--- a/src/main/kotlin/com/ex_dock/ex_dock/database/scope/createScopes.kt
+++ b/src/main/kotlin/com/ex_dock/ex_dock/database/scope/createScopes.kt
@@ -9,23 +9,31 @@ internal fun EventBus.createWebsite(client: MongoClient) {
   this.localConsumer<JsonObject>("process.scope.create.website").handler { message ->
     val data = message.body()
 
-    if (data.getString("_id") != null)
-      return@handler message.fail(400, "This function is for creating websites (scope), not editing them.")
-
-    val name = data.getString("scopeName")
-      ?: return@handler message.fail(400, "The name of the website (scope) is required.")
     val key = data.getString("scopeKey")
       ?: return@handler message.fail(400, "The key of the website (scope) is required.")
+    val name = data.getString("scopeName")
+      ?: return@handler message.fail(400, "The name of the website (scope) is required.")
 
-    val document = JsonObject()
-      .put("scopeName", name)
-      .put("scopKey", key)
-      .put("scopeType", "website")
-
-    client.insert(ScopeJdbcVerticle.CACHE_ADDRESS, document).onFailure { err ->
-      message.errorResponse(err)
+    client.findOne(
+      ScopeJdbcVerticle.CACHE_ADDRESS,
+      JsonObject().put("_id", key),
+      JsonObject().put("_id", 1),
+    ).onFailure { err ->
+      message.errorResponse(400, err)
     }.onSuccess { res ->
-      message.reply(res)
+      if (res != null)
+        return@onSuccess message.fail(409, "This function is for creating websites (scope), not editing them.")
+
+      val document = JsonObject()
+        .put("_id", key)
+        .put("scopeName", name)
+        .put("scopeType", "website")
+
+      client.insert(ScopeJdbcVerticle.CACHE_ADDRESS, document).onFailure { err ->
+        message.errorResponse(err)
+      }.onSuccess { res ->
+        message.reply(res)
+      }
     }
   }
 }
@@ -34,9 +42,6 @@ internal fun EventBus.createStoreView(client: MongoClient) {
   this.localConsumer<JsonObject>("process.scope.create.store-view").handler { message ->
     val data = message.body()
 
-    if (data.getString("_id") != null)
-      return@handler message.fail(400, "This function is for creating store-views (scope), not editing them.")
-
     val name = data.getString("name")
       ?: return@handler message.fail(400, "The name of the store-view (scope) is required.")
     val key = data.getString("key")
@@ -44,29 +49,40 @@ internal fun EventBus.createStoreView(client: MongoClient) {
     val websiteId = data.getString("websiteId")
       ?: return@handler message.fail(400, "The websiteId of the parent website (scope) is required.")
 
-    val searchWebsiteQuery = JsonObject().put("scopeType", "website").put("_id", websiteId)
-    client.find(ScopeJdbcVerticle.CACHE_ADDRESS, searchWebsiteQuery).onFailure { err ->
-      message.errorResponse(err)
+    client.findOne(
+      ScopeJdbcVerticle.CACHE_ADDRESS,
+      JsonObject().put("_id", key),
+      JsonObject().put("_id", 1),
+    ).onFailure { err ->
+      message.errorResponse(400, err)
     }.onSuccess { res ->
-      if (res.isEmpty())
-        return@onSuccess message.fail(400, "The websiteId of the parent website (scope) does not exist")
+      if (res != null)
+        return@onSuccess message.fail(409, "This function is for creating store-views (scope), not editing them.")
 
-      client.find(ScopeJdbcVerticle.CACHE_ADDRESS, JsonObject().put("scopKey", key)).onFailure { err ->
+      val searchWebsiteQuery = JsonObject().put("scopeType", "website").put("_id", websiteId)
+      client.find(ScopeJdbcVerticle.CACHE_ADDRESS, searchWebsiteQuery).onFailure { err ->
         message.errorResponse(err)
       }.onSuccess { res ->
-        if (res.isNotEmpty())
-          return@onSuccess message.fail(400, "The key of the store-view (scope) already exists for a scope")
+        if (res.isEmpty())
+          return@onSuccess message.fail(400, "The websiteId of the parent website (scope) does not exist")
 
-        val document = JsonObject()
-          .put("scopeName", name)
-          .put("scopKey", key)
-          .put("scopeType", "store-view")
-          .put("websiteId", websiteId)
-
-        client.insert(ScopeJdbcVerticle.CACHE_ADDRESS, document).onFailure { err ->
+        client.find(ScopeJdbcVerticle.CACHE_ADDRESS, JsonObject().put("_id", key)).onFailure { err ->
           message.errorResponse(err)
         }.onSuccess { res ->
-          message.reply(res)
+          if (res.isNotEmpty())
+            return@onSuccess message.fail(400, "The key of the store-view (scope) already exists for a scope")
+
+          val document = JsonObject()
+            .put("_id", key)
+            .put("scopeName", name)
+            .put("scopeType", "store-view")
+            .put("websiteId", websiteId)
+
+          client.insert(ScopeJdbcVerticle.CACHE_ADDRESS, document).onFailure { err ->
+            message.errorResponse(err)
+          }.onSuccess { res ->
+            message.reply(res)
+          }
         }
       }
     }

From f15547fa7c9ff526f331402ff228856b7db9dff7 Mon Sep 17 00:00:00 2001
From: Rens Pols <rens@cepols.nl>
Date: Fri, 10 Oct 2025 23:07:40 +0200
Subject: [PATCH 09/45] fix(core): Use Scope::class for delivery options

Replaces hardcoded string "ScopeCodec" with the class reference to get delivery options. This ensures type safety and avoids potential errors due to typos or inconsistencies.
---
 .../com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt    | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt b/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt
index 5b747957..a3c539bd 100644
--- a/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt
+++ b/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt
@@ -2,6 +2,7 @@ package com.ex_dock.ex_dock.database.scope
 
 import com.ex_dock.ex_dock.database.connection.getConnection
 import com.ex_dock.ex_dock.frontend.cache.setCacheFlag
+import com.ex_dock.ex_dock.helper.codecs.deliveryOptions
 import com.ex_dock.ex_dock.helper.replyListMessage
 import com.ex_dock.ex_dock.helper.replySingleMessage
 import io.vertx.core.Future
@@ -14,7 +15,7 @@ import io.vertx.ext.mongo.MongoClient
 class ScopeJdbcVerticle:  VerticleBase() {
   private lateinit var client: MongoClient
   private lateinit var eventBus: EventBus
-  private val fullScopeDeliveryOptions: DeliveryOptions = DeliveryOptions().setCodecName("ScopeCodec")
+  private val fullScopeDeliveryOptions: DeliveryOptions = Scope::class.deliveryOptions()
 
   companion object {
     const val CACHE_ADDRESS = "scopes"

From 7b7dfd789097f3e413782de54376ef78306ca3cd Mon Sep 17 00:00:00 2001
From: Rens Pols <rens@cepols.nl>
Date: Fri, 10 Oct 2025 23:08:00 +0200
Subject: [PATCH 10/45] feat(core): Add Attributes abstract class

Adds the Attributes abstract class to define attribute handling
in exDock. This class serves as the foundation for different
types of attributes, providing methods for getting, setting,
and clearing attribute values, as well as type checking. It
also defines abstract methods for attribute creation, deletion
and clearing all attributes.
---
 .../ex_dock/helper/attributes/Attributes.kt   | 159 ++++++++++++++++++
 1 file changed, 159 insertions(+)
 create mode 100644 src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt

diff --git a/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt b/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
new file mode 100644
index 00000000..d1e2b47b
--- /dev/null
+++ b/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
@@ -0,0 +1,159 @@
+package com.ex_dock.ex_dock.helper.attributes
+
+import com.ex_dock.ex_dock.helper.scopes.ScopeLevel
+import io.vertx.core.Future
+import io.vertx.core.json.JsonArray
+import io.vertx.core.json.JsonObject
+import io.vertx.ext.mongo.FindOptions
+import io.vertx.ext.mongo.MongoClient
+import kotlin.reflect.KClass
+
+
+/**
+ * The [Attributes] abstract class dictates the way that attributes are handled in exDock.
+ * It is the basis for all different types of attributes.
+ */
+abstract class Attributes(protected val client: MongoClient) {
+  abstract val collection: String
+
+  private fun getCollectionKey(scopeKey: String): String {
+    if (scopeKey == "global") return collection
+    return "$collection-$scopeKey"
+  }
+
+  fun getAttributeValue(entityId: String, attributeKey: String, scopeKey: String): Future<Any?> {
+    return Future.future { promise ->
+      client.findOne(
+        getCollectionKey(scopeKey),
+        JsonObject().put("_id", entityId),
+        JsonObject().put(attributeKey, 1),
+      ).onFailure { err ->
+        promise.fail(err)
+      }.onSuccess { res ->
+        promise.complete(res)
+      }
+    }
+  }
+
+  fun getAttributeValue(entityIds: List<String>, attributeKey: String, scopeKey: String): Future<List<Any?>> {
+    return Future.future { promise ->
+      client.findWithOptions(
+        getCollectionKey(scopeKey),
+        JsonObject().put("_id", JsonObject().put($$"$in", JsonArray(entityIds))),
+        FindOptions().setFields(JsonObject().put(attributeKey, 1)),
+      ).onFailure { err ->
+        promise.fail(err)
+      }.onSuccess { res ->
+        promise.complete(res)
+      }
+    }
+  }
+
+  fun getAttributesValue(entityId: String, attributeKeys: List<String>, scopeKey: String): Future<Any?> {
+    return Future.future { promise ->
+      val fields = JsonObject()
+      for (key in attributeKeys) fields.put(key, 1)
+      client.findOne(
+        getCollectionKey(scopeKey),
+        JsonObject().put("_id", entityId),
+        fields,
+      ).onFailure { err ->
+        promise.fail(err)
+      }.onSuccess { res ->
+        promise.complete(res)
+      }
+    }
+  }
+
+  fun getAttributesValue(entityId: String, scopeKey: String): Future<Any?> {
+    return Future.future { promise ->
+      client.findOne(
+        getCollectionKey(scopeKey),
+        JsonObject().put("_id", entityId),
+        null,
+      ).onFailure { err ->
+        promise.fail(err)
+      }.onSuccess { res ->
+        promise.complete(res)
+      }
+    }
+  }
+
+  abstract fun getAttributeType(attributeKey: String): KClass<*>
+  abstract fun checkValueType(attributeKey: String, value: Any): Boolean
+
+  fun setAttributeValue(entityId: String, attributeKey: String, value: Any, scopeKey: String): Future<Any> {
+    return Future.future { promise ->
+      if (!checkValueType(attributeKey, value)) return@future promise.fail(
+        "$value (type: ${value::class.simpleName}) is not the correct type for $attributeKey (type: ${getAttributeType(attributeKey).simpleName})")
+
+      client.findOneAndUpdate(
+        getCollectionKey(scopeKey),
+        JsonObject().put("_id", entityId),
+        JsonObject().put($$"$set", JsonObject().put(attributeKey, value)),
+      ).onFailure { err -> promise.fail(err) }.onSuccess { _ ->
+        promise.complete(value)
+      }
+    }
+  }
+  fun setAttributesValue(entityId: String, attributes: Map<String, Any>, scopeKey: String): Future<Map<String, Any>> {
+    return Future.future { promise ->
+      for ((attributeKey, value) in attributes) {
+        // TODO: save all wrong types and return it inside 1 fail()
+        if (!checkValueType(attributeKey, value)) return@future promise.fail(
+          "$value (type: ${value::class.simpleName}) is not the correct type for $attributeKey (type: ${getAttributeType(attributeKey).simpleName})")
+      }
+      client.findOneAndUpdate(
+        getCollectionKey(scopeKey),
+        JsonObject().put("_id", entityId),
+        JsonObject().put($$"$set", JsonObject(attributes)),
+      ).onFailure { err -> promise.fail(err) }.onSuccess { _ ->
+        promise.complete(attributes)
+      }
+    }
+  }
+
+  /**
+   * Clears the attribute for the entity.
+   *
+   * @throws IllegalArgumentException When you try to clear a required attribute.
+   */
+  fun clearAttributeValue(entityId: String, attributeKey: String, scopeKey: String): Future<Unit> {
+    return Future.future { promise ->
+      client.findOneAndUpdate(
+        getCollectionKey(scopeKey),
+        JsonObject().put("_id", entityId),
+        JsonObject().put($$"$unset", JsonObject().put(attributeKey, null)),
+      ).onFailure { err -> promise.fail(err) }.onSuccess { _ -> promise.complete() }
+    }
+  }
+  /**
+   * Clears the attributes for the entity.
+   *
+   * @throws IllegalArgumentException When you try to clear a required attribute.
+   */
+  fun clearAttributesValue(entityId: String, attributeKeys: List<String>, scopeKey: String): Future<Unit> {
+    val attributes = mutableMapOf<String, Any?>()
+    for (key in attributeKeys) attributes[key] = null
+
+    return Future.future { promise ->
+      client.findOneAndUpdate(
+        getCollectionKey(scopeKey),
+        JsonObject().put("_id", entityId),
+        JsonObject().put($$"$unset", JsonObject(attributes)),
+      ).onFailure { err -> promise.fail(err) }.onSuccess { _ -> promise.complete() }
+    }
+  }
+  /**
+   * Clears all the attributes for the entity. This is meant as an assist for the removal of the entityId
+   *
+   * Attention: Also removes the required attributes!
+   */
+  abstract fun clearAllAttributesValue(entityId: String)
+
+  abstract fun createAttribute(attributeName: String, attributeKey: String, dataType: String, scopeLevel: ScopeLevel)
+
+  // TODO: fun editAttribute()
+
+  abstract fun deleteAttribute(attributeKey: String)
+}

From 900e0aeecb53862e0e8e5b5f90f3cb40ded7fcf9 Mon Sep 17 00:00:00 2001
From: Rens Pols <rens@cepols.nl>
Date: Mon, 13 Oct 2025 14:34:30 +0200
Subject: [PATCH 11/45] refactor(scope): Simplify imports in ScopeJdbcVerticle

Removes unused imports and adds missing ones.
This improves code readability and ensures necessary
dependencies are available.
---
 .../com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt     | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt b/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt
index a3c539bd..604b1b7b 100644
--- a/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt
+++ b/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt
@@ -3,8 +3,6 @@ package com.ex_dock.ex_dock.database.scope
 import com.ex_dock.ex_dock.database.connection.getConnection
 import com.ex_dock.ex_dock.frontend.cache.setCacheFlag
 import com.ex_dock.ex_dock.helper.codecs.deliveryOptions
-import com.ex_dock.ex_dock.helper.replyListMessage
-import com.ex_dock.ex_dock.helper.replySingleMessage
 import io.vertx.core.Future
 import io.vertx.core.VerticleBase
 import io.vertx.core.eventbus.DeliveryOptions

From 486c303202e877dae9aa97f91e0a20ba3b3d0aad Mon Sep 17 00:00:00 2001
From: Rens Pols <rens@cepols.nl>
Date: Mon, 13 Oct 2025 14:48:16 +0200
Subject: [PATCH 12/45] refactor(scope): Refactor scope handling

Refactors scope handling logic and updates event bus
consumers for scope management.

Updates `getScopes.kt` to use cached scopes and modifies
`ScopeJdbcVerticle.kt` to align with changes in scope
handling and adds create website/storeview and edit/delete scope functionality.
---
 .../database/scope/ScopeJdbcVerticle.kt       |  3 +--
 .../ex_dock/database/scope/getScopes.kt       | 20 ++++---------------
 2 files changed, 5 insertions(+), 18 deletions(-)

diff --git a/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt b/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt
index 604b1b7b..90876a5f 100644
--- a/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt
+++ b/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt
@@ -26,8 +26,7 @@ class ScopeJdbcVerticle:  VerticleBase() {
     // Initialize all eventbus connections for basic scopes
     eventBus.getAllScopes(client)
     eventBus.getScopeById(client)
-    eventBus.getScopesByWebsiteName(client)
-    eventBus.getScopesByStoreViewName(client)
+    eventBus.getScopesByWebsiteId(client)
     eventBus.createWebsite(client)
     eventBus.createStoreView(client)
     editScope()
diff --git a/src/main/kotlin/com/ex_dock/ex_dock/database/scope/getScopes.kt b/src/main/kotlin/com/ex_dock/ex_dock/database/scope/getScopes.kt
index f0a40cc9..124155fe 100644
--- a/src/main/kotlin/com/ex_dock/ex_dock/database/scope/getScopes.kt
+++ b/src/main/kotlin/com/ex_dock/ex_dock/database/scope/getScopes.kt
@@ -17,8 +17,7 @@ internal fun EventBus.getAllScopes(client: MongoClient) {
 }
 
 internal fun EventBus.getScopeById(client: MongoClient) {
-  val getScopeByWebsiteIdConsumer = this.consumer<String>("process.scope.getScopeByWebsiteId")
-  getScopeByWebsiteIdConsumer.handler { message ->
+  this.consumer<String>("process.scope.getScopeById").handler { message ->
     val websiteId = message.body()
     val query = JsonObject()
       .put("_id", websiteId)
@@ -27,23 +26,12 @@ internal fun EventBus.getScopeById(client: MongoClient) {
   }
 }
 
-internal fun EventBus.getScopesByWebsiteName(client: MongoClient) {
-  val getScopesByWebsiteNameConsumer = this.consumer<String>("process.scope.getScopesByWebsiteName")
+internal fun EventBus.getScopesByWebsiteId(client: MongoClient) {
+  val getScopesByWebsiteNameConsumer = this.consumer<String>("process.scope.getScopesByWebsiteId")
   getScopesByWebsiteNameConsumer.handler { message ->
     val websiteName = message.body()
     val query = JsonObject()
-      .put("website_name", websiteName)
-
-    client.find("scopes", query).replyListMessage(message)
-  }
-}
-
-internal fun EventBus.getScopesByStoreViewName(client: MongoClient) {
-  val getScopesByStoreViewNameConsumer = this.consumer<String>("process.scope.getScopesByStoreViewName")
-  getScopesByStoreViewNameConsumer.handler { message ->
-    val storeViewName = message.body()
-    val query = JsonObject()
-      .put("store_view_name", storeViewName)
+      .put("websiteId", websiteName)
 
     client.find("scopes", query).replyListMessage(message)
   }

From f4f42cef04e820050fb213b998dd0b4dd661d3c2 Mon Sep 17 00:00:00 2001
From: Rens Pols <rens@cepols.nl>
Date: Mon, 13 Oct 2025 14:52:29 +0200
Subject: [PATCH 13/45] fix(core): Correctly handle error messages

Fixes incorrect variable name in error handling within ScopeJdbcVerticle, changing 'res' to 'err'.
---
 .../ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt   | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt b/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt
index 90876a5f..fb41fc14 100644
--- a/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt
+++ b/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt
@@ -74,12 +74,12 @@ class ScopeJdbcVerticle:  VerticleBase() {
 
       val rowsFuture = client.removeDocument("scopes", query)
 
-      rowsFuture.onFailure { res ->
-        println("Failed to execute query: $res")
-        message.fail(500, "Failed to execute query: $res")
+      rowsFuture.onFailure { err ->
+        println("Failed to execute query: $err")
+        message.fail(500, "Failed to execute query: $err")
       }
 
-      rowsFuture.onSuccess { res ->
+      rowsFuture.onSuccess { _ ->
         message.reply("Scope deleted successfully")
       }
     }

From b5b1dc3c3976f9c68fef54bf251a56d03a0c9dc0 Mon Sep 17 00:00:00 2001
From: Rens Pols <rens@cepols.nl>
Date: Mon, 13 Oct 2025 14:54:06 +0200
Subject: [PATCH 14/45] refactor(scope): Simplify ScopeJdbcVerticle

Removes unused editScope function and imports.
Improves deleteScope function's query execution.
---
 .../database/scope/ScopeJdbcVerticle.kt       | 30 +------------------
 1 file changed, 1 insertion(+), 29 deletions(-)

diff --git a/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt b/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt
index fb41fc14..f16e209a 100644
--- a/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt
+++ b/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt
@@ -29,40 +29,12 @@ class ScopeJdbcVerticle:  VerticleBase() {
     eventBus.getScopesByWebsiteId(client)
     eventBus.createWebsite(client)
     eventBus.createStoreView(client)
-    editScope()
     deleteScope()
 
     return Future.succeededFuture<Unit>()
   }
 
-  private fun editScope() {
-    // TODO: implement strict editScope functions and deprecate this global one
-    val editScopeConsumer = eventBus.consumer<Scope>("process.scope.editScope")
-    editScopeConsumer.handler { message ->
-      val body = message.body()
-      if (body.scopeId == null) {
-        message.fail(400, "No scope ID provided")
-        return@handler
-      }
-      val document = body.toDocument()
-      val rowsFuture = client.save("scopes", document)
-
-      rowsFuture.onFailure { res ->
-        println("Failed to execute query: $res")
-        message.fail(500, "Failed to execute query: $res")
-      }
-
-      rowsFuture.onSuccess { res ->
-        val lastInsertID: String? = res
-        if (lastInsertID != null) {
-          body.scopeId = lastInsertID
-        }
-
-        setCacheFlag(eventBus, CACHE_ADDRESS)
-        message.reply(body, fullScopeDeliveryOptions)
-      }
-    }
-  }
+  // TODO: create editScope functions
 
   private fun deleteScope() {
     // TODO: remove all data associated with the scope

From 63dd983efadda50b96ef3fa78d1d7933a5141f7e Mon Sep 17 00:00:00 2001
From: Rens Pols <rens@cepols.nl>
Date: Mon, 13 Oct 2025 14:55:19 +0200
Subject: [PATCH 15/45] feat(core): Implement in-memory scope caching

This commit introduces in-memory caching for scopes to improve performance.
The changes include:

- Added a `cachedScopes` variable to store scopes in memory.
- Updated `createScopes.kt`, `getScopes.kt`, and `ScopeJdbcVerticle.kt` to utilize and update the cache.
- Refactored `getScopes.kt` to initially load all scopes into the cache.
- Added new file `scopes.kt` to contain cachedScopes variable.
---
 .../ex_dock/database/scope/ScopeJdbcVerticle.kt   |  6 ++----
 .../ex_dock/database/scope/createScopes.kt        |  3 +++
 .../ex_dock/ex_dock/database/scope/getScopes.kt   | 15 ++++++++++++---
 .../kotlin/com/ex_dock/ex_dock/global/scopes.kt   |  5 +++++
 4 files changed, 22 insertions(+), 7 deletions(-)
 create mode 100644 src/main/kotlin/com/ex_dock/ex_dock/global/scopes.kt

diff --git a/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt b/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt
index f16e209a..5c730b2d 100644
--- a/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt
+++ b/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt
@@ -1,11 +1,9 @@
 package com.ex_dock.ex_dock.database.scope
 
 import com.ex_dock.ex_dock.database.connection.getConnection
-import com.ex_dock.ex_dock.frontend.cache.setCacheFlag
-import com.ex_dock.ex_dock.helper.codecs.deliveryOptions
+import com.ex_dock.ex_dock.global.cachedScopes
 import io.vertx.core.Future
 import io.vertx.core.VerticleBase
-import io.vertx.core.eventbus.DeliveryOptions
 import io.vertx.core.eventbus.EventBus
 import io.vertx.core.json.JsonObject
 import io.vertx.ext.mongo.MongoClient
@@ -13,7 +11,6 @@ import io.vertx.ext.mongo.MongoClient
 class ScopeJdbcVerticle:  VerticleBase() {
   private lateinit var client: MongoClient
   private lateinit var eventBus: EventBus
-  private val fullScopeDeliveryOptions: DeliveryOptions = Scope::class.deliveryOptions()
 
   companion object {
     const val CACHE_ADDRESS = "scopes"
@@ -52,6 +49,7 @@ class ScopeJdbcVerticle:  VerticleBase() {
       }
 
       rowsFuture.onSuccess { _ ->
+        cachedScopes.remove(scopeId)
         message.reply("Scope deleted successfully")
       }
     }
diff --git a/src/main/kotlin/com/ex_dock/ex_dock/database/scope/createScopes.kt b/src/main/kotlin/com/ex_dock/ex_dock/database/scope/createScopes.kt
index 2af150d8..17238b5b 100644
--- a/src/main/kotlin/com/ex_dock/ex_dock/database/scope/createScopes.kt
+++ b/src/main/kotlin/com/ex_dock/ex_dock/database/scope/createScopes.kt
@@ -1,5 +1,6 @@
 package com.ex_dock.ex_dock.database.scope
 
+import com.ex_dock.ex_dock.global.cachedScopes
 import com.ex_dock.ex_dock.helper.messages.errorResponse
 import io.vertx.core.eventbus.EventBus
 import io.vertx.core.json.JsonObject
@@ -32,6 +33,7 @@ internal fun EventBus.createWebsite(client: MongoClient) {
       client.insert(ScopeJdbcVerticle.CACHE_ADDRESS, document).onFailure { err ->
         message.errorResponse(err)
       }.onSuccess { res ->
+        cachedScopes.put(key, document)
         message.reply(res)
       }
     }
@@ -81,6 +83,7 @@ internal fun EventBus.createStoreView(client: MongoClient) {
           client.insert(ScopeJdbcVerticle.CACHE_ADDRESS, document).onFailure { err ->
             message.errorResponse(err)
           }.onSuccess { res ->
+            cachedScopes.put(key, document)
             message.reply(res)
           }
         }
diff --git a/src/main/kotlin/com/ex_dock/ex_dock/database/scope/getScopes.kt b/src/main/kotlin/com/ex_dock/ex_dock/database/scope/getScopes.kt
index 124155fe..ff018080 100644
--- a/src/main/kotlin/com/ex_dock/ex_dock/database/scope/getScopes.kt
+++ b/src/main/kotlin/com/ex_dock/ex_dock/database/scope/getScopes.kt
@@ -1,5 +1,6 @@
 package com.ex_dock.ex_dock.database.scope
 
+import com.ex_dock.ex_dock.global.cachedScopes
 import com.ex_dock.ex_dock.helper.replyListMessage
 import com.ex_dock.ex_dock.helper.replySingleMessage
 import io.vertx.core.eventbus.EventBus
@@ -12,7 +13,11 @@ internal fun EventBus.getAllScopes(client: MongoClient) {
   getAllScopesConsumer.handler { message ->
     val query = JsonObject()
 
-    client.find("scopes", query).replyListMessage(message)
+    client.find("scopes", query).onSuccess { res ->
+      val newCachedScopes = JsonObject()
+      for (scope in res) newCachedScopes.put(scope.getString("_id"), scope)
+      cachedScopes = newCachedScopes
+    }.replyListMessage(message)
   }
 }
 
@@ -22,7 +27,9 @@ internal fun EventBus.getScopeById(client: MongoClient) {
     val query = JsonObject()
       .put("_id", websiteId)
 
-    client.find("scopes", query).replySingleMessage(message)
+    client.find("scopes", query).onSuccess { res ->
+      cachedScopes.put(websiteId, res.first())
+    }.replySingleMessage(message)
   }
 }
 
@@ -33,6 +40,8 @@ internal fun EventBus.getScopesByWebsiteId(client: MongoClient) {
     val query = JsonObject()
       .put("websiteId", websiteName)
 
-    client.find("scopes", query).replyListMessage(message)
+    client.find("scopes", query).onSuccess { res ->
+      for (scope in res) cachedScopes.put(scope.getString("_id"), scope)
+    }.replyListMessage(message)
   }
 }
diff --git a/src/main/kotlin/com/ex_dock/ex_dock/global/scopes.kt b/src/main/kotlin/com/ex_dock/ex_dock/global/scopes.kt
new file mode 100644
index 00000000..f79786ab
--- /dev/null
+++ b/src/main/kotlin/com/ex_dock/ex_dock/global/scopes.kt
@@ -0,0 +1,5 @@
+package com.ex_dock.ex_dock.global
+
+import io.vertx.core.json.JsonObject
+
+var cachedScopes: JsonObject = JsonObject()

From d17cf165f7d873d395f06492b03efb3711febf82 Mon Sep 17 00:00:00 2001
From: Rens Pols <rens@cepols.nl>
Date: Mon, 13 Oct 2025 16:00:48 +0200
Subject: [PATCH 16/45] feat(attributes): Create getScopedDataSingle() function
 for use in the getAttributeValue functions

Refactors attribute retrieval logic for efficiency.
Uses cached scopes and Future.all for concurrent data
fetching from different scope levels (global, website,
scope). Fixes scoping and data merging.
---
 .../ex_dock/helper/attributes/Attributes.kt   | 65 +++++++++++++++++++
 1 file changed, 65 insertions(+)

diff --git a/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt b/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
index d1e2b47b..3a20058d 100644
--- a/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
+++ b/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
@@ -1,5 +1,6 @@
 package com.ex_dock.ex_dock.helper.attributes
 
+import com.ex_dock.ex_dock.global.cachedScopes
 import com.ex_dock.ex_dock.helper.scopes.ScopeLevel
 import io.vertx.core.Future
 import io.vertx.core.json.JsonArray
@@ -21,6 +22,70 @@ abstract class Attributes(protected val client: MongoClient) {
     return "$collection-$scopeKey"
   }
 
+  private fun getScopedDataSingle(
+      scopeKey: String,
+      query: JsonObject,
+      fields: JsonObject? = null
+  ): Future<JsonObject?> {
+    var globalData: JsonObject? = null
+    var websiteData: JsonObject? = null
+    var scopeData: JsonObject? = null
+    val allFutures = mutableListOf<Future<Unit>>()
+
+    val scope = cachedScopes.getJsonObject(scopeKey) ?: return Future.failedFuture("Scope not found")
+
+    allFutures.add(
+      Future.future { promise ->
+        client.findOne(getCollectionKey("global"), query, fields).onFailure { err ->
+          promise.fail(err)
+        }.onSuccess { res ->
+          globalData = res
+          promise.complete()
+        }
+      }
+    )
+
+    if (scopeKey != "global") {
+      allFutures.add(
+        Future.future { promise ->
+          client.findOne(getCollectionKey(scopeKey), query, fields).onFailure { err ->
+            promise.fail(err)
+          }.onSuccess { res ->
+            scopeData = res
+          }
+        }
+      )
+
+      if (scope.getString("scopeType") == "store-view") {
+        allFutures.add(
+          Future.future { promise ->
+            client.findOne(getCollectionKey(scope.getString("websiteId")), query, fields).onFailure { err ->
+              promise.fail(err)
+            }.onSuccess { res ->
+              websiteData = res
+              promise.complete()
+            }
+          }
+        )
+      }
+    }
+
+    return Future.future { promise ->
+      Future.all<Unit>(allFutures).onFailure { err ->
+        promise.fail(err)
+      }.onSuccess { _ ->
+        if (globalData == null && websiteData == null && scopeData == null) return@onSuccess promise.complete(null)
+
+        promise.complete(
+          (globalData ?: JsonObject()).apply {
+            if (websiteData != null) mergeIn(websiteData)
+            if (scopeData != null) mergeIn(scopeData)
+          }
+        )
+      }
+    }
+  }
+
   fun getAttributeValue(entityId: String, attributeKey: String, scopeKey: String): Future<Any?> {
     return Future.future { promise ->
       client.findOne(

From cf899385a5a6f91468120012b0d083d13ac577f0 Mon Sep 17 00:00:00 2001
From: Rens Pols <rens@cepols.nl>
Date: Mon, 13 Oct 2025 16:21:52 +0200
Subject: [PATCH 17/45] Feat(attributes): Added getScopedData for use in the
 getAttribute functions

Refactor `getAttributeValue` to retrieve data by scope,
allowing for global, website, and scope-specific data.
---
 .../ex_dock/helper/attributes/Attributes.kt   | 127 +++++++++++++++++-
 1 file changed, 125 insertions(+), 2 deletions(-)

diff --git a/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt b/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
index 3a20058d..c4edc717 100644
--- a/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
+++ b/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
@@ -86,6 +86,116 @@ abstract class Attributes(protected val client: MongoClient) {
     }
   }
 
+  private fun getScopedData(scopeKey: String, query: JsonObject, fields: JsonObject? = null): Future<List<JsonObject>> {
+    var globalData: List<JsonObject>? = null
+    var websiteData: List<JsonObject>? = null
+    var scopeData: List<JsonObject>? = null
+    val allFutures = mutableListOf<Future<Unit>>()
+
+    val scope = cachedScopes.getJsonObject(scopeKey) ?: return Future.failedFuture("Scope not found")
+    val findOptions = FindOptions().setFields(fields ?: JsonObject())
+
+    allFutures.add(
+      Future.future { promise ->
+        client.findWithOptions(
+          getCollectionKey("global"),
+          query,
+          findOptions,
+        ).onFailure { err ->
+          promise.fail(err)
+        }.onSuccess { res ->
+          globalData = res
+          promise.complete()
+        }
+      }
+    )
+
+    if (scopeKey != "global") {
+      allFutures.add(
+        Future.future { promise ->
+          client.findWithOptions(getCollectionKey(scopeKey), query, findOptions).onFailure { err ->
+            promise.fail(err)
+          }.onSuccess { res ->
+            scopeData = res
+          }
+        }
+      )
+
+      if (scope.getString("scopeType") == "store-view") {
+        allFutures.add(
+          Future.future { promise ->
+            client.findWithOptions(getCollectionKey(scope.getString("websiteId")), query, findOptions).onFailure { err ->
+              promise.fail(err)
+            }.onSuccess { res ->
+              websiteData = res
+              promise.complete()
+            }
+          }
+        )
+      }
+    }
+
+    return Future.future { promise ->
+      Future.all<Unit>(allFutures).onFailure { err ->
+        promise.fail(err)
+      }.onSuccess { _ ->
+        // Should never happen, but just to be sure
+        if (globalData == null && websiteData == null && scopeData == null) return@onSuccess promise.complete(null)
+
+        val globalDataMap = mutableMapOf<String, JsonObject>()
+        val websiteDataMap = mutableMapOf<String, JsonObject>()
+        val scopeDataMap = mutableMapOf<String, JsonObject>()
+        val allIds = mutableListOf<String>()
+
+        globalData?.forEach { data ->
+          val id = data.getString("_id")
+          allIds.add(id)
+          globalDataMap[id] = data
+        }
+        websiteData?.forEach { data ->
+          val id = data.getString("_id")
+          allIds.add(id)
+          websiteDataMap[id] = data
+        }
+        scopeData?.forEach { data ->
+          val id = data.getString("_id")
+          allIds.add(id)
+          scopeDataMap[id] = data
+        }
+
+        val result = mutableListOf<JsonObject>()
+
+        allIds.forEach { id ->
+          var websiteDone = false
+          var scopeDone = false
+          var data: JsonObject? = globalDataMap[id]
+          if (data == null) {
+            data = websiteDataMap[id]
+            websiteDone = true
+            if (data == null) {
+              data = scopeDataMap[id]
+              scopeDone = true
+            }
+          }
+
+          val websiteData = websiteDataMap[id]
+          if (!websiteDone && websiteData != null) {
+            data!!.mergeIn(websiteData)
+          }
+
+          val scopeData = scopeDataMap[id]
+          if (!scopeDone && scopeData != null) {
+            data!!.mergeIn(scopeData)
+          }
+
+          if (data != null) result.add(data)
+        }
+
+        promise.complete(result)
+      }
+    }
+  }
+
   fun getAttributeValue(entityId: String, attributeKey: String, scopeKey: String): Future<Any?> {
     return Future.future { promise ->
       client.findOne(
@@ -150,7 +260,12 @@ abstract class Attributes(protected val client: MongoClient) {
   fun setAttributeValue(entityId: String, attributeKey: String, value: Any, scopeKey: String): Future<Any> {
     return Future.future { promise ->
       if (!checkValueType(attributeKey, value)) return@future promise.fail(
-        "$value (type: ${value::class.simpleName}) is not the correct type for $attributeKey (type: ${getAttributeType(attributeKey).simpleName})")
+        "$value (type: ${value::class.simpleName}) is not the correct type for $attributeKey (type: ${
+          getAttributeType(
+            attributeKey
+          ).simpleName
+        })"
+      )
 
       client.findOneAndUpdate(
         getCollectionKey(scopeKey),
@@ -161,12 +276,18 @@ abstract class Attributes(protected val client: MongoClient) {
       }
     }
   }
+
   fun setAttributesValue(entityId: String, attributes: Map<String, Any>, scopeKey: String): Future<Map<String, Any>> {
     return Future.future { promise ->
       for ((attributeKey, value) in attributes) {
         // TODO: save all wrong types and return it inside 1 fail()
         if (!checkValueType(attributeKey, value)) return@future promise.fail(
-          "$value (type: ${value::class.simpleName}) is not the correct type for $attributeKey (type: ${getAttributeType(attributeKey).simpleName})")
+          "$value (type: ${value::class.simpleName}) is not the correct type for $attributeKey (type: ${
+            getAttributeType(
+              attributeKey
+            ).simpleName
+          })"
+        )
       }
       client.findOneAndUpdate(
         getCollectionKey(scopeKey),
@@ -192,6 +313,7 @@ abstract class Attributes(protected val client: MongoClient) {
       ).onFailure { err -> promise.fail(err) }.onSuccess { _ -> promise.complete() }
     }
   }
+
   /**
    * Clears the attributes for the entity.
    *
@@ -209,6 +331,7 @@ abstract class Attributes(protected val client: MongoClient) {
       ).onFailure { err -> promise.fail(err) }.onSuccess { _ -> promise.complete() }
     }
   }
+
   /**
    * Clears all the attributes for the entity. This is meant as an assist for the removal of the entityId
    *

From 95155bcdf7bb0c87448f33e53df17357402eceb4 Mon Sep 17 00:00:00 2001
From: Rens Pols <rens@cepols.nl>
Date: Mon, 13 Oct 2025 16:22:09 +0200
Subject: [PATCH 18/45] refactor(attributes): Make getScopedData functions
 internal

The getScopedData and getScopedDataSingle functions were
changed from private to internal, increasing their visibility
within the module. This allows for greater flexibility and
testability.
---
 .../com/ex_dock/ex_dock/helper/attributes/Attributes.kt       | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt b/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
index c4edc717..32b8fe23 100644
--- a/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
+++ b/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
@@ -22,7 +22,7 @@ abstract class Attributes(protected val client: MongoClient) {
     return "$collection-$scopeKey"
   }
 
-  private fun getScopedDataSingle(
+  internal fun getScopedDataSingle(
       scopeKey: String,
       query: JsonObject,
       fields: JsonObject? = null
@@ -86,7 +86,7 @@ abstract class Attributes(protected val client: MongoClient) {
     }
   }
 
-  private fun getScopedData(scopeKey: String, query: JsonObject, fields: JsonObject? = null): Future<List<JsonObject>> {
+  internal fun getScopedData(scopeKey: String, query: JsonObject, fields: JsonObject? = null): Future<List<JsonObject>> {
     var globalData: List<JsonObject>? = null
     var websiteData: List<JsonObject>? = null
     var scopeData: List<JsonObject>? = null

From 3c77c9d9907900d4629b8fd12b1fd7fa5eed0e30 Mon Sep 17 00:00:00 2001
From: Rens Pols <rens@cepols.nl>
Date: Mon, 13 Oct 2025 16:22:58 +0200
Subject: [PATCH 19/45] refactor(attributes): Change client visibility to
 internal

The `client` field in the `Attributes` class was changed
from `protected` to `internal`. This restricts access to
only modules within the same package.
---
 .../kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt b/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
index 32b8fe23..4c33c9b4 100644
--- a/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
+++ b/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
@@ -14,7 +14,7 @@ import kotlin.reflect.KClass
  * The [Attributes] abstract class dictates the way that attributes are handled in exDock.
  * It is the basis for all different types of attributes.
  */
-abstract class Attributes(protected val client: MongoClient) {
+abstract class Attributes(internal val client: MongoClient) {
   abstract val collection: String
 
   private fun getCollectionKey(scopeKey: String): String {

From 2a932a250a559af3f17510369ac205cfd7fd86ec Mon Sep 17 00:00:00 2001
From: Rens Pols <rens@cepols.nl>
Date: Mon, 13 Oct 2025 16:33:47 +0200
Subject: [PATCH 20/45] refactor(attributes): Replace cliend.find(One)() with
 getScopedData(Single)()

---
 .../ex_dock/helper/attributes/Attributes.kt        | 14 +++++---------
 1 file changed, 5 insertions(+), 9 deletions(-)

diff --git a/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt b/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
index 4c33c9b4..7022690e 100644
--- a/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
+++ b/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
@@ -198,11 +198,7 @@ abstract class Attributes(internal val client: MongoClient) {
 
   fun getAttributeValue(entityId: String, attributeKey: String, scopeKey: String): Future<Any?> {
     return Future.future { promise ->
-      client.findOne(
-        getCollectionKey(scopeKey),
-        JsonObject().put("_id", entityId),
-        JsonObject().put(attributeKey, 1),
-      ).onFailure { err ->
+      getScopedDataSingle(scopeKey, JsonObject().put("_id", entityId), JsonObject().put(attributeKey, 1)).onFailure { err ->
         promise.fail(err)
       }.onSuccess { res ->
         promise.complete(res)
@@ -212,10 +208,10 @@ abstract class Attributes(internal val client: MongoClient) {
 
   fun getAttributeValue(entityIds: List<String>, attributeKey: String, scopeKey: String): Future<List<Any?>> {
     return Future.future { promise ->
-      client.findWithOptions(
+      getScopedData(
         getCollectionKey(scopeKey),
         JsonObject().put("_id", JsonObject().put($$"$in", JsonArray(entityIds))),
-        FindOptions().setFields(JsonObject().put(attributeKey, 1)),
+        JsonObject().put(attributeKey, 1),
       ).onFailure { err ->
         promise.fail(err)
       }.onSuccess { res ->
@@ -228,7 +224,7 @@ abstract class Attributes(internal val client: MongoClient) {
     return Future.future { promise ->
       val fields = JsonObject()
       for (key in attributeKeys) fields.put(key, 1)
-      client.findOne(
+      getScopedDataSingle(
         getCollectionKey(scopeKey),
         JsonObject().put("_id", entityId),
         fields,
@@ -242,7 +238,7 @@ abstract class Attributes(internal val client: MongoClient) {
 
   fun getAttributesValue(entityId: String, scopeKey: String): Future<Any?> {
     return Future.future { promise ->
-      client.findOne(
+      getScopedDataSingle(
         getCollectionKey(scopeKey),
         JsonObject().put("_id", entityId),
         null,

From a892ec42f75a542c42c71cea67a034ed22779181 Mon Sep 17 00:00:00 2001
From: Rens Pols <rens@cepols.nl>
Date: Mon, 13 Oct 2025 16:38:50 +0200
Subject: [PATCH 21/45] refactor(core): Make getCollectionKey internal

The function `getCollectionKey` was changed from private to internal.
This allows it to be accessed from other modules within the project.
---
 .../kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt b/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
index 7022690e..359ea7c3 100644
--- a/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
+++ b/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
@@ -17,7 +17,7 @@ import kotlin.reflect.KClass
 abstract class Attributes(internal val client: MongoClient) {
   abstract val collection: String
 
-  private fun getCollectionKey(scopeKey: String): String {
+  internal fun getCollectionKey(scopeKey: String): String {
     if (scopeKey == "global") return collection
     return "$collection-$scopeKey"
   }

From 63a640f5552befacc08ae94c9d598a8bdbb64caa Mon Sep 17 00:00:00 2001
From: Rens Pols <rens@cepols.nl>
Date: Mon, 13 Oct 2025 16:55:25 +0200
Subject: [PATCH 22/45] fix(core): Make clearAllAttributesValue non-abstract

The `clearAllAttributesValue` function was made non-abstract and implemented to remove attribute values for a given entity ID from all cached scopes and the main collection. This change ensures that attribute values are properly cleared across the entire system.
---
 .../ex_dock/helper/attributes/Attributes.kt        | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt b/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
index 359ea7c3..ef327bc0 100644
--- a/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
+++ b/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
@@ -333,7 +333,19 @@ abstract class Attributes(internal val client: MongoClient) {
    *
    * Attention: Also removes the required attributes!
    */
-  abstract fun clearAllAttributesValue(entityId: String)
+  fun clearAllAttributesValue(entityId: String): Future<Unit> {
+    val query = JsonObject().put("_id", entityId)
+    val allFutures = mutableListOf<Future<*>>()
+    for ((key, _) in cachedScopes) allFutures.add(client.removeDocument(getCollectionKey(key), query))
+    allFutures.add(client.removeDocument(collection, query))
+    return Future.future { promise ->
+      Future.all<Unit>(allFutures).onFailure { err ->
+        promise.fail(err)
+      }.onSuccess { _ ->
+        promise.complete()
+      }
+    }
+  }
 
   abstract fun createAttribute(attributeName: String, attributeKey: String, dataType: String, scopeLevel: ScopeLevel)
 

From 57b48abeb9b24d095ca5483a3ab284678069041f Mon Sep 17 00:00:00 2001
From: Rens Pols <rens@cepols.nl>
Date: Mon, 20 Oct 2025 13:26:46 +0200
Subject: [PATCH 23/45] feat(core): Add attribute key validation

Adds `isValidAttributeKey` to validate attribute keys.
Uses regex to enforce naming conventions.
---
 .../ex_dock/ex_dock/helper/attributes/Attributes.kt  | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt b/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
index ef327bc0..8ce5fa3d 100644
--- a/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
+++ b/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
@@ -22,6 +22,18 @@ abstract class Attributes(internal val client: MongoClient) {
     return "$collection-$scopeKey"
   }
 
+  internal fun isValidAttributeKey(attributeKey: String): Boolean {
+    if (attributeKey.length < 4) return false
+
+    // Regular expression explanation:
+    // ^[a-zA-Z]             - Must start with a letter (upper or lower case).
+    // [a-zA-Z0-9_-]* - Followed by zero or more of: letters, numbers, hyphen, or underscore.
+    // [a-zA-Z0-9]$          - MUST end with a letter or a number.
+    //                         This ensures the key cannot end with a hyphen or an underscore.
+    val regex = Regex("^[a-zA-Z][a-zA-Z0-9_-]*[a-zA-Z0-9]$")
+    return attributeKey.matches(regex)
+  }
+
   internal fun getScopedDataSingle(
       scopeKey: String,
       query: JsonObject,

From c93a21359fce1c40cc1b287019918450603d8dc0 Mon Sep 17 00:00:00 2001
From: Rens Pols <rens@cepols.nl>
Date: Mon, 20 Oct 2025 13:33:31 +0200
Subject: [PATCH 24/45] feat(core): Add Future.onFailure(promise) extension
 function

Adds extension function to handle Future failures by failing the provided Promise.
---
 .../helper/futures/future_handle_parent_future.kt      | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 src/main/kotlin/com/ex_dock/ex_dock/helper/futures/future_handle_parent_future.kt

diff --git a/src/main/kotlin/com/ex_dock/ex_dock/helper/futures/future_handle_parent_future.kt b/src/main/kotlin/com/ex_dock/ex_dock/helper/futures/future_handle_parent_future.kt
new file mode 100644
index 00000000..a65e7fee
--- /dev/null
+++ b/src/main/kotlin/com/ex_dock/ex_dock/helper/futures/future_handle_parent_future.kt
@@ -0,0 +1,10 @@
+package com.ex_dock.ex_dock.helper.futures
+
+import io.vertx.core.Future
+import io.vertx.core.Promise
+
+fun <T> Future<T>.onFailure(promise: Promise<*>): Future<T> {
+  return this.onFailure { err ->
+    promise.fail(err)
+  }
+}

From 05a2b615f62db731427c9ff69d3c127d29b03e2e Mon Sep 17 00:00:00 2001
From: Rens Pols <rens@cepols.nl>
Date: Mon, 20 Oct 2025 14:28:40 +0200
Subject: [PATCH 25/45] refactor(core): Refactor Attributes class to use an
 async attributes configuration

The Attributes class was refactored to handle the async attributes configuration.
Specifically includes:

- Renamed getAttributeType function to return a Future to handle asynchronous type checking.
- Moved `checkValueType` to return a Future to support async value validation.
- Modified `setAttributeValue` and `setAttributesValue` to perform asynchronous type checking before setting attributes.
- Added proper Future handling for asynchronous operations.
---
 .../ex_dock/helper/attributes/Attributes.kt   | 136 ++++++++++++------
 1 file changed, 96 insertions(+), 40 deletions(-)

diff --git a/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt b/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
index 8ce5fa3d..69f8d3a6 100644
--- a/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
+++ b/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
@@ -1,6 +1,7 @@
 package com.ex_dock.ex_dock.helper.attributes
 
 import com.ex_dock.ex_dock.global.cachedScopes
+import com.ex_dock.ex_dock.helper.futures.onFailure
 import com.ex_dock.ex_dock.helper.scopes.ScopeLevel
 import io.vertx.core.Future
 import io.vertx.core.json.JsonArray
@@ -98,7 +99,11 @@ abstract class Attributes(internal val client: MongoClient) {
     }
   }
 
-  internal fun getScopedData(scopeKey: String, query: JsonObject, fields: JsonObject? = null): Future<List<JsonObject>> {
+  internal fun getScopedData(
+      scopeKey: String,
+      query: JsonObject,
+      fields: JsonObject? = null
+  ): Future<List<JsonObject>> {
     var globalData: List<JsonObject>? = null
     var websiteData: List<JsonObject>? = null
     var scopeData: List<JsonObject>? = null
@@ -136,12 +141,13 @@ abstract class Attributes(internal val client: MongoClient) {
       if (scope.getString("scopeType") == "store-view") {
         allFutures.add(
           Future.future { promise ->
-            client.findWithOptions(getCollectionKey(scope.getString("websiteId")), query, findOptions).onFailure { err ->
-              promise.fail(err)
-            }.onSuccess { res ->
-              websiteData = res
-              promise.complete()
-            }
+            client.findWithOptions(getCollectionKey(scope.getString("websiteId")), query, findOptions)
+              .onFailure { err ->
+                promise.fail(err)
+              }.onSuccess { res ->
+                websiteData = res
+                promise.complete()
+              }
           }
         )
       }
@@ -210,7 +216,11 @@ abstract class Attributes(internal val client: MongoClient) {
 
   fun getAttributeValue(entityId: String, attributeKey: String, scopeKey: String): Future<Any?> {
     return Future.future { promise ->
-      getScopedDataSingle(scopeKey, JsonObject().put("_id", entityId), JsonObject().put(attributeKey, 1)).onFailure { err ->
+      getScopedDataSingle(
+        scopeKey,
+        JsonObject().put("_id", entityId),
+        JsonObject().put(attributeKey, 1)
+      ).onFailure { err ->
         promise.fail(err)
       }.onSuccess { res ->
         promise.complete(res)
@@ -262,47 +272,88 @@ abstract class Attributes(internal val client: MongoClient) {
     }
   }
 
-  abstract fun getAttributeType(attributeKey: String): KClass<*>
-  abstract fun checkValueType(attributeKey: String, value: Any): Boolean
+  abstract fun getAttributeType(attributeKey: String): Future<KClass<*>>
+  abstract fun checkValueType(attributeKey: String, value: Any): Future<Boolean>
 
   fun setAttributeValue(entityId: String, attributeKey: String, value: Any, scopeKey: String): Future<Any> {
     return Future.future { promise ->
-      if (!checkValueType(attributeKey, value)) return@future promise.fail(
-        "$value (type: ${value::class.simpleName}) is not the correct type for $attributeKey (type: ${
-          getAttributeType(
-            attributeKey
-          ).simpleName
-        })"
-      )
+      checkValueType(attributeKey, value).onFailure(promise).onSuccess { res ->
+        if (!res) {
+          getAttributeType(attributeKey).onComplete { asyncRes ->
+            promise.fail(
+              "$value (type: ${value::class.simpleName}) is not the correct type for $attributeKey (type: ${asyncRes.result() ?: "type name could not be retrieved"})"
+            )
+          }
+          return@onSuccess
+        }
 
-      client.findOneAndUpdate(
-        getCollectionKey(scopeKey),
-        JsonObject().put("_id", entityId),
-        JsonObject().put($$"$set", JsonObject().put(attributeKey, value)),
-      ).onFailure { err -> promise.fail(err) }.onSuccess { _ ->
-        promise.complete(value)
+        client.findOneAndUpdate(
+          getCollectionKey(scopeKey),
+          JsonObject().put("_id", entityId),
+          JsonObject().put($$"$set", JsonObject().put(attributeKey, value)),
+        ).onFailure(promise).onSuccess { _ ->
+          promise.complete(value)
+        }
       }
     }
   }
 
   fun setAttributesValue(entityId: String, attributes: Map<String, Any>, scopeKey: String): Future<Map<String, Any>> {
     return Future.future { promise ->
-      for ((attributeKey, value) in attributes) {
-        // TODO: save all wrong types and return it inside 1 fail()
-        if (!checkValueType(attributeKey, value)) return@future promise.fail(
-          "$value (type: ${value::class.simpleName}) is not the correct type for $attributeKey (type: ${
-            getAttributeType(
-              attributeKey
-            ).simpleName
-          })"
-        )
+      val checkValueType: List<Future<Boolean>> = attributes.map { (attributeKey, value) ->
+        checkValueType(attributeKey, value)
       }
-      client.findOneAndUpdate(
-        getCollectionKey(scopeKey),
-        JsonObject().put("_id", entityId),
-        JsonObject().put($$"$set", JsonObject(attributes)),
-      ).onFailure { err -> promise.fail(err) }.onSuccess { _ ->
-        promise.complete(attributes)
+
+      val attributeKeyList = attributes.keys.toList()
+      val wrongTypeAttributeValues = mutableMapOf<String, Any>()
+
+      Future.all<Boolean>(checkValueType).onFailure(promise).onSuccess { asyncRes ->
+        asyncRes.list<Boolean>().forEachIndexed { index, res ->
+          if (!res) {
+            val attributeKey = attributeKeyList[index]
+            wrongTypeAttributeValues[attributeKey] = attributes[attributeKey]!!
+          }
+        }
+
+        if (wrongTypeAttributeValues.isNotEmpty()) {
+          val errorMessages = mutableListOf<String>()
+
+          val typeNameFutures: List<Future<KClass<*>?>> = wrongTypeAttributeValues.keys.map { attributeKey ->
+            Future.future { promise ->
+              getAttributeType(attributeKey).onComplete { asyncRes ->
+                promise.complete(asyncRes.result())
+              }
+            }
+          }
+
+          Future.all<KClass<*>>(typeNameFutures).onFailure(promise).onSuccess { res ->
+            wrongTypeAttributeValues.entries.forEachIndexed { index, (key, value) ->
+              val expectedTypeName =
+                (res.resultAt(index) as KClass<*>)::class.simpleName ?: "type name could not be retrieved"
+              errorMessages.add(
+                "$value (type: ${value::class.simpleName}) is not the correct type for $key (type: $expectedTypeName)"
+              )
+            }
+          }
+
+          promise.fail(
+            "The following type errors occurred while trying to set multiple attributes: \n- " +
+                errorMessages.joinToString("\n- ") +
+                "\n\nThe complete set attributes operation was aborted."
+          )
+
+          return@onSuccess
+        }
+
+        client.findOneAndUpdate(
+          getCollectionKey(scopeKey),
+          JsonObject().put("_id", entityId),
+          JsonObject().put($$"$set", JsonObject(attributes)),
+        ).onFailure { err -> promise.fail(err) }.onSuccess { _ ->
+          promise.complete(attributes)
+        }
+
+        return@onSuccess
       }
     }
   }
@@ -359,9 +410,14 @@ abstract class Attributes(internal val client: MongoClient) {
     }
   }
 
-  abstract fun createAttribute(attributeName: String, attributeKey: String, dataType: String, scopeLevel: ScopeLevel)
+  abstract fun createAttribute(
+      attributeName: String,
+      attributeKey: String,
+      dataType: String,
+      scopeLevel: ScopeLevel
+  ): Future<Unit>
 
   // TODO: fun editAttribute()
 
-  abstract fun deleteAttribute(attributeKey: String)
+  abstract fun deleteAttribute(attributeKey: String): Future<Unit>
 }

From d020bb4268138987288c5e7ae52fbd75886b2d7c Mon Sep 17 00:00:00 2001
From: Rens Pols <rens@cepols.nl>
Date: Mon, 20 Oct 2025 15:17:03 +0200
Subject: [PATCH 26/45] feat(futures): Add Future.onSuccess(promise) extension
 function

Adds onSuccess method to complement onFailure for promise completion.
---
 .../helper/futures/future_handle_parent_future.kt    | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/src/main/kotlin/com/ex_dock/ex_dock/helper/futures/future_handle_parent_future.kt b/src/main/kotlin/com/ex_dock/ex_dock/helper/futures/future_handle_parent_future.kt
index a65e7fee..ff8485a6 100644
--- a/src/main/kotlin/com/ex_dock/ex_dock/helper/futures/future_handle_parent_future.kt
+++ b/src/main/kotlin/com/ex_dock/ex_dock/helper/futures/future_handle_parent_future.kt
@@ -3,8 +3,20 @@ package com.ex_dock.ex_dock.helper.futures
 import io.vertx.core.Future
 import io.vertx.core.Promise
 
+/**
+ * This onFailure method replaces the standard onFailure { promise.fail(it) }
+ */
 fun <T> Future<T>.onFailure(promise: Promise<*>): Future<T> {
   return this.onFailure { err ->
     promise.fail(err)
   }
 }
+
+/**
+ * This onSuccess method replaces the standard onSuccess { promise.complete(it) }
+ */
+fun <T> Future<T>.onSuccess(promise: Promise<T>): Future<T> {
+  return this.onSuccess { res ->
+    promise.complete(res)
+  }
+}

From e1befc7c2ada306aa35c34050c2847d0533adf09 Mon Sep 17 00:00:00 2001
From: Rens Pols <rens@cepols.nl>
Date: Mon, 20 Oct 2025 15:23:25 +0200
Subject: [PATCH 27/45] feat(core): Add onSuccess extension function for
 Promise<Unit>

This adds an `onSuccess` extension function to `Future`
that completes a provided `Promise` when the `Future`
completes successfully.
---
 .../helper/futures/future_handle_parent_future.kt        | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/src/main/kotlin/com/ex_dock/ex_dock/helper/futures/future_handle_parent_future.kt b/src/main/kotlin/com/ex_dock/ex_dock/helper/futures/future_handle_parent_future.kt
index ff8485a6..8ce1a5d7 100644
--- a/src/main/kotlin/com/ex_dock/ex_dock/helper/futures/future_handle_parent_future.kt
+++ b/src/main/kotlin/com/ex_dock/ex_dock/helper/futures/future_handle_parent_future.kt
@@ -20,3 +20,12 @@ fun <T> Future<T>.onSuccess(promise: Promise<T>): Future<T> {
     promise.complete(res)
   }
 }
+
+/**
+ * This onSuccess method replaces the standard onSuccess { promise.complete() }
+ */
+fun <T> Future<T>.onSuccess(promise: Promise<Unit>): Future<T> {
+  return this.onSuccess { _ ->
+    promise.complete()
+  }
+}

From 7990ca99b92abb1634bece52e198076fa0100cc9 Mon Sep 17 00:00:00 2001
From: Rens Pols <rens@cepols.nl>
Date: Mon, 20 Oct 2025 15:28:50 +0200
Subject: [PATCH 28/45] Fix(core): Add abstract val allowedTypes to
 Attributes.kt

Adds an abstract val allowedTypes property to the Attributes class
---
 .../kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt   | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt b/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
index 69f8d3a6..dfc01f8c 100644
--- a/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
+++ b/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
@@ -17,6 +17,7 @@ import kotlin.reflect.KClass
  */
 abstract class Attributes(internal val client: MongoClient) {
   abstract val collection: String
+  abstract val allowedTypes: Map<String, KClass<*>>
 
   internal fun getCollectionKey(scopeKey: String): String {
     if (scopeKey == "global") return collection

From 7828c9460e535d65275c279b6e651215315049f6 Mon Sep 17 00:00:00 2001
From: Rens Pols <rens@cepols.nl>
Date: Mon, 20 Oct 2025 15:37:52 +0200
Subject: [PATCH 29/45] refactor(core): Improve attribute type checking

Updates checkValueType method to use KClass.
---
 .../com/ex_dock/ex_dock/helper/attributes/Attributes.kt      | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt b/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
index dfc01f8c..8f54660c 100644
--- a/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
+++ b/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
@@ -274,7 +274,10 @@ abstract class Attributes(internal val client: MongoClient) {
   }
 
   abstract fun getAttributeType(attributeKey: String): Future<KClass<*>>
-  abstract fun checkValueType(attributeKey: String, value: Any): Future<Boolean>
+  abstract fun checkValueType(attributeKey: String, kClass: KClass<*>): Future<Boolean>
+  fun checkValueType(attributeKey: String, value: Any): Future<Boolean> {
+    return checkValueType(attributeKey, value::class)
+  }
 
   fun setAttributeValue(entityId: String, attributeKey: String, value: Any, scopeKey: String): Future<Any> {
     return Future.future { promise ->

From ed3f814bc93001fd17d48c20da91d55752695587 Mon Sep 17 00:00:00 2001
From: Rens Pols <rens@cepols.nl>
Date: Mon, 20 Oct 2025 15:42:37 +0200
Subject: [PATCH 30/45] refactor(attributes): Refactor attribute value checks

The `checkValueType` methods and `setAttributeValue` and `setAttributesValue` functions were refactored to improve type checking and error handling for attribute values. The changes ensure that the correct type is used for each attribute, and clearer error messages are displayed when type mismatches occur.
---
 .../com/ex_dock/ex_dock/helper/attributes/Attributes.kt   | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt b/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
index 8f54660c..6be951fb 100644
--- a/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
+++ b/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
@@ -274,7 +274,13 @@ abstract class Attributes(internal val client: MongoClient) {
   }
 
   abstract fun getAttributeType(attributeKey: String): Future<KClass<*>>
-  abstract fun checkValueType(attributeKey: String, kClass: KClass<*>): Future<Boolean>
+  fun checkValueType(attributeKey: String, kClass: KClass<*>): Future<Boolean> {
+    return Future.future { promise ->
+      getAttributeType(attributeKey).onFailure(promise).onSuccess { res ->
+        promise.complete(res == kClass)
+      }
+    }
+  }
   fun checkValueType(attributeKey: String, value: Any): Future<Boolean> {
     return checkValueType(attributeKey, value::class)
   }

From e700a53acd661732b1adf364129f7e47ea30556f Mon Sep 17 00:00:00 2001
From: Rens Pols <rens@cepols.nl>
Date: Mon, 20 Oct 2025 15:59:07 +0200
Subject: [PATCH 31/45] Refactor(attributes): Improve attribute management

This commit refactors the Attributes class to improve
attribute management and add support for creating
attributes. The changes include:

- Add validation for attribute keys
- Improve the logic for retrieving scoped data
- Add support for creating attributes
---
 .../ex_dock/helper/attributes/Attributes.kt   | 39 +++++++++++++++++--
 1 file changed, 35 insertions(+), 4 deletions(-)

diff --git a/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt b/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
index 6be951fb..3ec82bcf 100644
--- a/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
+++ b/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
@@ -2,6 +2,7 @@ package com.ex_dock.ex_dock.helper.attributes
 
 import com.ex_dock.ex_dock.global.cachedScopes
 import com.ex_dock.ex_dock.helper.futures.onFailure
+import com.ex_dock.ex_dock.helper.futures.onSuccess
 import com.ex_dock.ex_dock.helper.scopes.ScopeLevel
 import io.vertx.core.Future
 import io.vertx.core.json.JsonArray
@@ -17,6 +18,7 @@ import kotlin.reflect.KClass
  */
 abstract class Attributes(internal val client: MongoClient) {
   abstract val collection: String
+  val collectionConfigKey = "$collection-attributes"
   abstract val allowedTypes: Map<String, KClass<*>>
 
   internal fun getCollectionKey(scopeKey: String): String {
@@ -273,7 +275,21 @@ abstract class Attributes(internal val client: MongoClient) {
     }
   }
 
-  abstract fun getAttributeType(attributeKey: String): Future<KClass<*>>
+  fun getAttributeType(attributeKey: String): Future<KClass<*>> {
+    return Future.future { promise ->
+      client.findOne(
+        collectionConfigKey,
+        JsonObject().put("_id", attributeKey),
+        JsonObject().put("type", 1)
+      ).onFailure(promise).onSuccess { res ->
+        promise.complete(
+          allowedTypes[res.getString("type")]
+            ?: throw IllegalStateException("For some reason, the attribute type for this attributeKey is not in the allowedTypes map... This means that the KClass can't be matched and returned. A database repair is required")
+        )
+      }
+    }
+  }
+
   fun checkValueType(attributeKey: String, kClass: KClass<*>): Future<Boolean> {
     return Future.future { promise ->
       getAttributeType(attributeKey).onFailure(promise).onSuccess { res ->
@@ -281,6 +297,7 @@ abstract class Attributes(internal val client: MongoClient) {
       }
     }
   }
+
   fun checkValueType(attributeKey: String, value: Any): Future<Boolean> {
     return checkValueType(attributeKey, value::class)
   }
@@ -420,14 +437,28 @@ abstract class Attributes(internal val client: MongoClient) {
     }
   }
 
-  abstract fun createAttribute(
+  fun createAttribute(
       attributeName: String,
       attributeKey: String,
       dataType: String,
       scopeLevel: ScopeLevel
-  ): Future<Unit>
+  ): Future<Unit> {
+    if (!isValidAttributeKey(attributeKey)) return Future.failedFuture("Invalid attribute key")
+    if (allowedTypes[dataType] == null) return Future.failedFuture("Invalid data type")
+    return Future.future { promise ->
+      val document = JsonObject()
+        .put("_id", attributeKey)
+        .put("name", attributeName)
+        .put("type", dataType)
+        .put("scopeLevel", scopeLevel.name)
+      client.insert(collectionConfigKey, document).onFailure(promise).onSuccess(promise)
+    }
+  }
 
   // TODO: fun editAttribute()
 
-  abstract fun deleteAttribute(attributeKey: String): Future<Unit>
+  fun deleteAttribute(attributeKey: String): Future<Unit> {
+    // TODO: remove all attributeValues for this attribute on all scopes
+    TODO("Not yet implemented")
+  }
 }

From c78f56210fb2c2353aabb359164ca877995d09b5 Mon Sep 17 00:00:00 2001
From: Rens Pols <rens@cepols.nl>
Date: Mon, 20 Oct 2025 15:59:22 +0200
Subject: [PATCH 32/45] feat(attributes): Add ProductAttributes class

Adds a `ProductAttributes` class that extends `Attributes`.
This class defines the allowed types for product attributes
and the collection name for products.
---
 .../ex_dock/helper/attributes/ProductAttributes.kt | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/ProductAttributes.kt

diff --git a/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/ProductAttributes.kt b/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/ProductAttributes.kt
new file mode 100644
index 00000000..69cd8fe4
--- /dev/null
+++ b/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/ProductAttributes.kt
@@ -0,0 +1,14 @@
+package com.ex_dock.ex_dock.helper.attributes
+
+import io.vertx.ext.mongo.MongoClient
+import kotlin.reflect.KClass
+
+class ProductAttributes(client: MongoClient) : Attributes(client) {
+  override val collection: String = "products"
+  override val allowedTypes: Map<String, KClass<*>> = mapOf(
+    "string" to String::class,
+    "integer" to Int::class,
+    "number" to Number::class,
+    "boolean" to Boolean::class,
+  )
+}

From 2b91bdde0fba1b2d1fc15c1010e4a571724ea95c Mon Sep 17 00:00:00 2001
From: Rens Pols <rens@cepols.nl>
Date: Mon, 20 Oct 2025 16:06:58 +0200
Subject: [PATCH 33/45] Grammar correction

---
 .../kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt b/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
index 3ec82bcf..fa1282db 100644
--- a/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
+++ b/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
@@ -419,7 +419,7 @@ abstract class Attributes(internal val client: MongoClient) {
   }
 
   /**
-   * Clears all the attributes for the entity. This is meant as an assist for the removal of the entityId
+   * Clears all the attributes for the entity. This is meant as an assist for the removal of the entityId.
    *
    * Attention: Also removes the required attributes!
    */

From 1f3b6ee057621d1f74fe1fcb7b63b513b05cd72f Mon Sep 17 00:00:00 2001
From: Rens Pols <rens@cepols.nl>
Date: Mon, 20 Oct 2025 16:17:17 +0200
Subject: [PATCH 34/45] feat(attributes): Add clearAttributeAllValues() to
 Attributes.kt

Adds function to clear all values for an attribute.
This assists with attribute removal by resetting values.
---
 .../ex_dock/helper/attributes/Attributes.kt   | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt b/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
index fa1282db..9db1c891 100644
--- a/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
+++ b/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
@@ -437,6 +437,30 @@ abstract class Attributes(internal val client: MongoClient) {
     }
   }
 
+  /**
+   * Clears all the values for a certain attribute across all scopes. This is meant as an assist for the removal of an attribute.
+   */
+  fun clearAttributeAllValues(attributeKey: String): Future<Unit> {
+    return Future.future { promise ->
+      val allFutures = mutableListOf<Future<*>>()
+      for ((key, _) in cachedScopes) allFutures.add(
+        client.updateCollection(
+          getCollectionKey(key),
+          JsonObject(),
+          JsonObject().put($$"$unset", JsonObject().put(attributeKey, null))
+        )
+      )
+      allFutures.add(
+        client.updateCollection(
+          collection,
+          JsonObject(),
+          JsonObject().put($$"$unset", JsonObject().put(attributeKey, null))
+        )
+      )
+      Future.all<Any?>(allFutures).onFailure(promise).onSuccess(promise)
+    }
+  }
+
   fun createAttribute(
       attributeName: String,
       attributeKey: String,

From 351ac5d166c5429507315b9669784cd907177ed1 Mon Sep 17 00:00:00 2001
From: Rens Pols <rens@cepols.nl>
Date: Mon, 20 Oct 2025 16:41:40 +0200
Subject: [PATCH 35/45] feat(futures): Add Future.onComplete extension
 functions

Adds extension functions to Future to simplify
handling both success and failure cases for promises.
This avoids redundant code.
---
 .../helper/futures/future_handle_parent_future.kt  | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/src/main/kotlin/com/ex_dock/ex_dock/helper/futures/future_handle_parent_future.kt b/src/main/kotlin/com/ex_dock/ex_dock/helper/futures/future_handle_parent_future.kt
index 8ce1a5d7..23a74273 100644
--- a/src/main/kotlin/com/ex_dock/ex_dock/helper/futures/future_handle_parent_future.kt
+++ b/src/main/kotlin/com/ex_dock/ex_dock/helper/futures/future_handle_parent_future.kt
@@ -29,3 +29,17 @@ fun <T> Future<T>.onSuccess(promise: Promise<Unit>): Future<T> {
     promise.complete()
   }
 }
+
+/**
+ * This onComplete method replaces the standard .onFailure { promise.fail(it) }.onSuccess { promise.complete(it) }
+ */
+fun <T> Future<T>.onComplete(promise: Promise<T>): Future<T> {
+  return this.onFailure(promise).onSuccess(promise)
+}
+
+/**
+ * This onComplete method replaces the standard .onFailure { promise.fail(it) }.onSuccess { promise.complete() }
+ */
+fun <T> Future<T>.onComplete(promise: Promise<Unit>): Future<T> {
+  return this.onFailure(promise).onSuccess(promise)
+}

From 3dce3e6dd9fcce41f1d0e36467cfe60c6a72165d Mon Sep 17 00:00:00 2001
From: Rens Pols <rens@cepols.nl>
Date: Mon, 20 Oct 2025 16:43:37 +0200
Subject: [PATCH 36/45] feat(attributes): implement deleteAttribute in
 Attributes.kt

---
 .../com/ex_dock/ex_dock/helper/attributes/Attributes.kt   | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt b/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
index 9db1c891..51c4199c 100644
--- a/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
+++ b/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
@@ -1,6 +1,7 @@
 package com.ex_dock.ex_dock.helper.attributes
 
 import com.ex_dock.ex_dock.global.cachedScopes
+import com.ex_dock.ex_dock.helper.futures.onComplete
 import com.ex_dock.ex_dock.helper.futures.onFailure
 import com.ex_dock.ex_dock.helper.futures.onSuccess
 import com.ex_dock.ex_dock.helper.scopes.ScopeLevel
@@ -482,7 +483,10 @@ abstract class Attributes(internal val client: MongoClient) {
   // TODO: fun editAttribute()
 
   fun deleteAttribute(attributeKey: String): Future<Unit> {
-    // TODO: remove all attributeValues for this attribute on all scopes
-    TODO("Not yet implemented")
+    return Future.future { promise ->
+      clearAttributeAllValues(attributeKey).onFailure(promise).onSuccess { _ ->
+        client.removeDocument(collectionConfigKey, JsonObject().put("_id", attributeKey)).onComplete(promise)
+      }
+    }
   }
 }

From eabd912bb8c5c0bcc16bc49e3e0e470d0cc93431 Mon Sep 17 00:00:00 2001
From: Rens Pols <rens@cepols.nl>
Date: Mon, 20 Oct 2025 16:51:42 +0200
Subject: [PATCH 37/45] Improved naming for the attributes config keys

---
 .../ex_dock/ex_dock/helper/attributes/Attributes.kt    | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt b/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
index 51c4199c..b93fa58e 100644
--- a/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
+++ b/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
@@ -281,10 +281,10 @@ abstract class Attributes(internal val client: MongoClient) {
       client.findOne(
         collectionConfigKey,
         JsonObject().put("_id", attributeKey),
-        JsonObject().put("type", 1)
+        JsonObject().put("attributeType", 1)
       ).onFailure(promise).onSuccess { res ->
         promise.complete(
-          allowedTypes[res.getString("type")]
+          allowedTypes[res.getString("attributeType")]
             ?: throw IllegalStateException("For some reason, the attribute type for this attributeKey is not in the allowedTypes map... This means that the KClass can't be matched and returned. A database repair is required")
         )
       }
@@ -473,9 +473,9 @@ abstract class Attributes(internal val client: MongoClient) {
     return Future.future { promise ->
       val document = JsonObject()
         .put("_id", attributeKey)
-        .put("name", attributeName)
-        .put("type", dataType)
-        .put("scopeLevel", scopeLevel.name)
+        .put("attributeName", attributeName)
+        .put("attributeType", dataType)
+        .put("attributeScopeLevel", scopeLevel.name)
       client.insert(collectionConfigKey, document).onFailure(promise).onSuccess(promise)
     }
   }

From f8dffefb53afc76d427ecf831e350a0ae0748b0d Mon Sep 17 00:00:00 2001
From: Rens Pols <rens@cepols.nl>
Date: Mon, 20 Oct 2025 16:52:49 +0200
Subject: [PATCH 38/45] feat(attributes): Add AttributeConfiguration data class

Adds AttributeConfiguration.kt to define the structure
for attribute configurations including key, name, data
type, and scope level.  Provides a toDocument() function
for converting to a JsonObject.
---
 .../attributes/AttributeConfiguration.kt      | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/AttributeConfiguration.kt

diff --git a/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/AttributeConfiguration.kt b/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/AttributeConfiguration.kt
new file mode 100644
index 00000000..8b1f3f2e
--- /dev/null
+++ b/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/AttributeConfiguration.kt
@@ -0,0 +1,19 @@
+package com.ex_dock.ex_dock.helper.attributes
+
+import com.ex_dock.ex_dock.helper.scopes.ScopeLevel
+import io.vertx.core.json.JsonObject
+
+data class AttributeConfiguration(
+  val attributeKey: String,
+  val attributeName: String,
+  val attributeDataType: String,
+  val scopeLevel: ScopeLevel,
+) {
+  fun toDocument(): JsonObject {
+    return JsonObject()
+      .put("_id", attributeKey)
+      .put("attributeName", attributeName)
+      .put("attributeType", attributeDataType)
+      .put("attributeScopeLevel", scopeLevel.name)
+  }
+}
\ No newline at end of file

From 9ab4c7458edcdf291e7dd18475c25d2ed00ec54c Mon Sep 17 00:00:00 2001
From: Rens Pols <rens@cepols.nl>
Date: Mon, 20 Oct 2025 16:55:00 +0200
Subject: [PATCH 39/45] Refactor(attributes): Implement system attributes

This commit introduces the concept of system attributes and refactors the ProductAttributes class to include them.

- Adds a `systemAttributes` property to the `Attributes` class.
- Implements the `systemAttributes` in `ProductAttributes` class.
---
 .../com/ex_dock/ex_dock/helper/attributes/Attributes.kt     | 1 +
 .../ex_dock/ex_dock/helper/attributes/ProductAttributes.kt  | 6 ++++++
 2 files changed, 7 insertions(+)

diff --git a/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt b/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
index b93fa58e..8f1068ff 100644
--- a/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
+++ b/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
@@ -21,6 +21,7 @@ abstract class Attributes(internal val client: MongoClient) {
   abstract val collection: String
   val collectionConfigKey = "$collection-attributes"
   abstract val allowedTypes: Map<String, KClass<*>>
+  abstract val systemAttributes: List<AttributeConfiguration>
 
   internal fun getCollectionKey(scopeKey: String): String {
     if (scopeKey == "global") return collection
diff --git a/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/ProductAttributes.kt b/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/ProductAttributes.kt
index 69cd8fe4..a8923cb2 100644
--- a/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/ProductAttributes.kt
+++ b/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/ProductAttributes.kt
@@ -1,5 +1,6 @@
 package com.ex_dock.ex_dock.helper.attributes
 
+import com.ex_dock.ex_dock.helper.scopes.ScopeLevel
 import io.vertx.ext.mongo.MongoClient
 import kotlin.reflect.KClass
 
@@ -11,4 +12,9 @@ class ProductAttributes(client: MongoClient) : Attributes(client) {
     "number" to Number::class,
     "boolean" to Boolean::class,
   )
+  override val systemAttributes: List<AttributeConfiguration> = listOf(
+    AttributeConfiguration("name", "Product name", "string", ScopeLevel.STORE_VIEW),
+    AttributeConfiguration("description", "Product description", "string", ScopeLevel.STORE_VIEW),
+    // TODO: think about all system attributes for the products
+  )
 }

From 028bcb3dd9233f52d56895e7f5ce636ebabbf2be Mon Sep 17 00:00:00 2001
From: Rens Pols <rens@cepols.nl>
Date: Mon, 20 Oct 2025 17:02:41 +0200
Subject: [PATCH 40/45] feat(attributes): Add initialiseSystemAttributes
 function

Adds an empty `initialiseSystemAttributes` function to the
`Attributes` class. This function will check for missing
system attributes and add them.
---
 .../com/ex_dock/ex_dock/helper/attributes/Attributes.kt  | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt b/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
index 8f1068ff..6aefe265 100644
--- a/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
+++ b/src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/Attributes.kt
@@ -490,4 +490,13 @@ abstract class Attributes(internal val client: MongoClient) {
       }
     }
   }
+
+  /**
+   * This function checks if the system attributes are present, and if not, add all the missing attributes.
+   *
+   * Future will fail when system attributes are present, but the config doesn't match or on database error.
+   */
+  fun initialiseSystemAttributes(): Future<Unit> {
+    TODO("Not yet implemented")
+  }
 }

From b863dfc3c1f751e62df8c5580c48d30f0f670391 Mon Sep 17 00:00:00 2001
From: Rens Pols <rens@cepols.nl>
Date: Mon, 3 Nov 2025 19:39:36 +0100
Subject: [PATCH 41/45] Resolve JVM name conflict for future parent-promise
 handlers

---
 .../ex_dock/helper/futures/future_handle_parent_future.kt       | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/main/kotlin/com/ex_dock/ex_dock/helper/futures/future_handle_parent_future.kt b/src/main/kotlin/com/ex_dock/ex_dock/helper/futures/future_handle_parent_future.kt
index 23a74273..548d98f7 100644
--- a/src/main/kotlin/com/ex_dock/ex_dock/helper/futures/future_handle_parent_future.kt
+++ b/src/main/kotlin/com/ex_dock/ex_dock/helper/futures/future_handle_parent_future.kt
@@ -24,6 +24,7 @@ fun <T> Future<T>.onSuccess(promise: Promise<T>): Future<T> {
 /**
  * This onSuccess method replaces the standard onSuccess { promise.complete() }
  */
+@JvmName("onSuccessUnit") // Make the JVM name unique for the Unit version
 fun <T> Future<T>.onSuccess(promise: Promise<Unit>): Future<T> {
   return this.onSuccess { _ ->
     promise.complete()
@@ -40,6 +41,7 @@ fun <T> Future<T>.onComplete(promise: Promise<T>): Future<T> {
 /**
  * This onComplete method replaces the standard .onFailure { promise.fail(it) }.onSuccess { promise.complete() }
  */
+@JvmName("onCompleteUnit") // Make the JVM name unique for the Unit version
 fun <T> Future<T>.onComplete(promise: Promise<Unit>): Future<T> {
   return this.onFailure(promise).onSuccess(promise)
 }

From 31f476996f96306a05a4534cb30f4a9ff2a25ddd Mon Sep 17 00:00:00 2001
From: Rens Pols <rens@cepols.nl>
Date: Mon, 3 Nov 2025 21:00:09 +0100
Subject: [PATCH 42/45] Make sure that "process.scope.create.website" will
 always return the id

---
 .../kotlin/com/ex_dock/ex_dock/database/scope/createScopes.kt   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/kotlin/com/ex_dock/ex_dock/database/scope/createScopes.kt b/src/main/kotlin/com/ex_dock/ex_dock/database/scope/createScopes.kt
index 17238b5b..6323c2ca 100644
--- a/src/main/kotlin/com/ex_dock/ex_dock/database/scope/createScopes.kt
+++ b/src/main/kotlin/com/ex_dock/ex_dock/database/scope/createScopes.kt
@@ -34,7 +34,7 @@ internal fun EventBus.createWebsite(client: MongoClient) {
         message.errorResponse(err)
       }.onSuccess { res ->
         cachedScopes.put(key, document)
-        message.reply(res)
+        message.reply(res ?: key)
       }
     }
   }

From 5c679f7527a7f917ff0dfba2bf7a07dea7a8fb55 Mon Sep 17 00:00:00 2001
From: Rens Pols <rens@cepols.nl>
Date: Mon, 3 Nov 2025 21:06:04 +0100
Subject: [PATCH 43/45] Cleaned up "process.scope.deleteScope"

---
 .../ex_dock/database/scope/ScopeJdbcVerticle.kt  | 16 ++++++----------
 1 file changed, 6 insertions(+), 10 deletions(-)

diff --git a/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt b/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt
index 5c730b2d..27c5d9b7 100644
--- a/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt
+++ b/src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt
@@ -1,7 +1,9 @@
 package com.ex_dock.ex_dock.database.scope
 
+import com.ex_dock.ex_dock.MainVerticle
 import com.ex_dock.ex_dock.database.connection.getConnection
 import com.ex_dock.ex_dock.global.cachedScopes
+import com.ex_dock.ex_dock.helper.messages.errorResponse
 import io.vertx.core.Future
 import io.vertx.core.VerticleBase
 import io.vertx.core.eventbus.EventBus
@@ -35,20 +37,14 @@ class ScopeJdbcVerticle:  VerticleBase() {
 
   private fun deleteScope() {
     // TODO: remove all data associated with the scope
-    val deleteScopeConsumer = eventBus.consumer<String>("process.scope.deleteScope")
-    deleteScopeConsumer.handler { message ->
+    eventBus.consumer<String>("process.scope.deleteScope").handler { message ->
       val scopeId = message.body()
       val query = JsonObject()
         .put("_id", scopeId)
 
-      val rowsFuture = client.removeDocument("scopes", query)
-
-      rowsFuture.onFailure { err ->
-        println("Failed to execute query: $err")
-        message.fail(500, "Failed to execute query: $err")
-      }
-
-      rowsFuture.onSuccess { _ ->
+      client.removeDocument("scopes", query).onFailure { err ->
+        message.errorResponse(500, "Failed to execute query: $err")
+      }.onSuccess { _ ->
         cachedScopes.remove(scopeId)
         message.reply("Scope deleted successfully")
       }

From 760ead413b2467ba161eafaa845deaa8d0ff8cf0 Mon Sep 17 00:00:00 2001
From: Rens Pols <rens@cepols.nl>
Date: Mon, 3 Nov 2025 21:32:52 +0100
Subject: [PATCH 44/45] Fix ScopeJdbcVerticleTest.kt

---
 .../com/ex_dock/ex_dock/database/scope/createScopes.kt      | 2 +-
 .../kotlin/com/ex_dock/ex_dock/database/scope/getScopes.kt  | 6 ++----
 .../ex_dock/ex_dock/database/scope/ScopeJdbcVerticleTest.kt | 3 +--
 3 files changed, 4 insertions(+), 7 deletions(-)

diff --git a/src/main/kotlin/com/ex_dock/ex_dock/database/scope/createScopes.kt b/src/main/kotlin/com/ex_dock/ex_dock/database/scope/createScopes.kt
index 6323c2ca..90b98d4a 100644
--- a/src/main/kotlin/com/ex_dock/ex_dock/database/scope/createScopes.kt
+++ b/src/main/kotlin/com/ex_dock/ex_dock/database/scope/createScopes.kt
@@ -84,7 +84,7 @@ internal fun EventBus.createStoreView(client: MongoClient) {
             message.errorResponse(err)
           }.onSuccess { res ->
             cachedScopes.put(key, document)
-            message.reply(res)
+            message.reply(res ?: key)
           }
         }
       }
diff --git a/src/main/kotlin/com/ex_dock/ex_dock/database/scope/getScopes.kt b/src/main/kotlin/com/ex_dock/ex_dock/database/scope/getScopes.kt
index ff018080..e20bd3c3 100644
--- a/src/main/kotlin/com/ex_dock/ex_dock/database/scope/getScopes.kt
+++ b/src/main/kotlin/com/ex_dock/ex_dock/database/scope/getScopes.kt
@@ -9,8 +9,7 @@ import io.vertx.ext.mongo.MongoClient
 
 
 internal fun EventBus.getAllScopes(client: MongoClient) {
-  val getAllScopesConsumer = this.consumer<String>("process.scope.getAllScopes")
-  getAllScopesConsumer.handler { message ->
+  this.consumer<String>("process.scope.getAllScopes").handler { message ->
     val query = JsonObject()
 
     client.find("scopes", query).onSuccess { res ->
@@ -34,8 +33,7 @@ internal fun EventBus.getScopeById(client: MongoClient) {
 }
 
 internal fun EventBus.getScopesByWebsiteId(client: MongoClient) {
-  val getScopesByWebsiteNameConsumer = this.consumer<String>("process.scope.getScopesByWebsiteId")
-  getScopesByWebsiteNameConsumer.handler { message ->
+  this.consumer<String>("process.scope.getScopesByWebsiteId").handler { message ->
     val websiteName = message.body()
     val query = JsonObject()
       .put("websiteId", websiteName)
diff --git a/src/test/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticleTest.kt b/src/test/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticleTest.kt
index 96083a9f..1e2fe657 100644
--- a/src/test/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticleTest.kt
+++ b/src/test/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticleTest.kt
@@ -4,7 +4,6 @@ import com.ex_dock.ex_dock.helper.codecs.registerGenericCodec
 import com.ex_dock.ex_dock.helper.deployWorkerVerticleHelper
 import io.vertx.core.Vertx
 import io.vertx.core.eventbus.EventBus
-import io.vertx.core.json.JsonArray
 import io.vertx.core.json.JsonObject
 import io.vertx.junit5.VertxExtension
 import io.vertx.junit5.VertxTestContext
@@ -132,7 +131,7 @@ class ScopeJdbcVerticleTest {
   @Order(4)
   @DisplayName("Test getting a scope by its ID")
   fun testGetScopeById(context: VertxTestContext) {
-    eventBus.request<JsonObject>("process.scope.getScopeByWebsiteId", testWebsiteId).onFailure {
+    eventBus.request<JsonObject>("process.scope.getScopeById", testWebsiteId).onFailure {
       context.failNow(it)
     }.onSuccess { message ->
       val result = message.body()

From b10d9b75883f613bdc4968f03b8add6883e7d1dd Mon Sep 17 00:00:00 2001
From: Rens Pols <rens@cepols.nl>
Date: Mon, 3 Nov 2025 21:54:43 +0100
Subject: [PATCH 45/45] Use the ObjectId class for creating a scope

---
 .../ex_dock/database/scope/createScopes.kt    | 61 ++++++++++---------
 1 file changed, 33 insertions(+), 28 deletions(-)

diff --git a/src/main/kotlin/com/ex_dock/ex_dock/database/scope/createScopes.kt b/src/main/kotlin/com/ex_dock/ex_dock/database/scope/createScopes.kt
index 90b98d4a..32a9cc81 100644
--- a/src/main/kotlin/com/ex_dock/ex_dock/database/scope/createScopes.kt
+++ b/src/main/kotlin/com/ex_dock/ex_dock/database/scope/createScopes.kt
@@ -5,15 +5,16 @@ import com.ex_dock.ex_dock.helper.messages.errorResponse
 import io.vertx.core.eventbus.EventBus
 import io.vertx.core.json.JsonObject
 import io.vertx.ext.mongo.MongoClient
+import org.bson.types.ObjectId
 
 internal fun EventBus.createWebsite(client: MongoClient) {
   this.localConsumer<JsonObject>("process.scope.create.website").handler { message ->
     val data = message.body()
 
-    val key = data.getString("scopeKey")
-      ?: return@handler message.fail(400, "The key of the website (scope) is required.")
-    val name = data.getString("scopeName")
-      ?: return@handler message.fail(400, "The name of the website (scope) is required.")
+    val keyString = data.getString("scopeKey") ?: return@handler message.fail(400, "The key of the website (scope) is required.")
+    val key = ObjectId(keyString)
+    val name =
+      data.getString("scopeName") ?: return@handler message.fail(400, "The name of the website (scope) is required.")
 
     client.findOne(
       ScopeJdbcVerticle.CACHE_ADDRESS,
@@ -22,18 +23,17 @@ internal fun EventBus.createWebsite(client: MongoClient) {
     ).onFailure { err ->
       message.errorResponse(400, err)
     }.onSuccess { res ->
-      if (res != null)
-        return@onSuccess message.fail(409, "This function is for creating websites (scope), not editing them.")
+      if (res != null) return@onSuccess message.fail(
+        409,
+        "This function is for creating websites (scope), not editing them."
+      )
 
-      val document = JsonObject()
-        .put("_id", key)
-        .put("scopeName", name)
-        .put("scopeType", "website")
+      val document = JsonObject().put("_id", key).put("scopeName", name).put("scopeType", "website")
 
       client.insert(ScopeJdbcVerticle.CACHE_ADDRESS, document).onFailure { err ->
         message.errorResponse(err)
       }.onSuccess { res ->
-        cachedScopes.put(key, document)
+        cachedScopes.put(keyString, document)
         message.reply(res ?: key)
       }
     }
@@ -44,12 +44,14 @@ internal fun EventBus.createStoreView(client: MongoClient) {
   this.localConsumer<JsonObject>("process.scope.create.store-view").handler { message ->
     val data = message.body()
 
-    val name = data.getString("name")
-      ?: return@handler message.fail(400, "The name of the store-view (scope) is required.")
-    val key = data.getString("key")
-      ?: return@handler message.fail(400, "The key of the store-view (scope) is required.")
-    val websiteId = data.getString("websiteId")
-      ?: return@handler message.fail(400, "The websiteId of the parent website (scope) is required.")
+    val name =
+      data.getString("name") ?: return@handler message.fail(400, "The name of the store-view (scope) is required.")
+    val keyString = data.getString("key") ?: return@handler message.fail(400, "The key of the store-view (scope) is required.")
+    val key = ObjectId(keyString)
+    val websiteId = data.getString("websiteId") ?: return@handler message.fail(
+      400,
+      "The websiteId of the parent website (scope) is required."
+    )
 
     client.findOne(
       ScopeJdbcVerticle.CACHE_ADDRESS,
@@ -58,32 +60,35 @@ internal fun EventBus.createStoreView(client: MongoClient) {
     ).onFailure { err ->
       message.errorResponse(400, err)
     }.onSuccess { res ->
-      if (res != null)
-        return@onSuccess message.fail(409, "This function is for creating store-views (scope), not editing them.")
+      if (res != null) return@onSuccess message.fail(
+        409,
+        "This function is for creating store-views (scope), not editing them."
+      )
 
       val searchWebsiteQuery = JsonObject().put("scopeType", "website").put("_id", websiteId)
       client.find(ScopeJdbcVerticle.CACHE_ADDRESS, searchWebsiteQuery).onFailure { err ->
         message.errorResponse(err)
       }.onSuccess { res ->
-        if (res.isEmpty())
-          return@onSuccess message.fail(400, "The websiteId of the parent website (scope) does not exist")
+        if (res.isEmpty()) return@onSuccess message.fail(
+          400,
+          "The websiteId of the parent website (scope) does not exist"
+        )
 
         client.find(ScopeJdbcVerticle.CACHE_ADDRESS, JsonObject().put("_id", key)).onFailure { err ->
           message.errorResponse(err)
         }.onSuccess { res ->
-          if (res.isNotEmpty())
-            return@onSuccess message.fail(400, "The key of the store-view (scope) already exists for a scope")
+          if (res.isNotEmpty()) return@onSuccess message.fail(
+            400,
+            "The key of the store-view (scope) already exists for a scope"
+          )
 
-          val document = JsonObject()
-            .put("_id", key)
-            .put("scopeName", name)
-            .put("scopeType", "store-view")
+          val document = JsonObject().put("_id", key).put("scopeName", name).put("scopeType", "store-view")
             .put("websiteId", websiteId)
 
           client.insert(ScopeJdbcVerticle.CACHE_ADDRESS, document).onFailure { err ->
             message.errorResponse(err)
           }.onSuccess { res ->
-            cachedScopes.put(key, document)
+            cachedScopes.put(keyString, document)
             message.reply(res ?: key)
           }
         }