DOPE-281: system info

core/src/main/kotlin/ch/ergon/dope/resolvable/bucket/Bucket.kt

@@ -9,14 +9,13 @@ import ch.ergon.dope.resolvable.Updatable
 import ch.ergon.dope.resolvable.expression.SingleExpression
 import ch.ergon.dope.validtype.ObjectType
 
-sealed interface Bucket : Fromable, Joinable, Nestable, Deletable, Updatable, SingleExpression<ObjectType> {
+interface Bucket : Fromable, Joinable, Nestable, Deletable, Updatable, SingleExpression<ObjectType> {
     val name: String
     val scope: BucketScope?
 }
 
 data class BucketScope(val name: String, val collection: ScopeCollection? = null) {
     fun withCollection(collectionName: String) = copy(collection = ScopeCollection(collectionName))
-
     fun withCollection(collection: ScopeCollection) = copy(collection = collection)
 }
 
@@ -26,7 +25,6 @@ data class UnaliasedBucket(
     override val name: String,
     override val scope: BucketScope? = null,
 ) : Bucket {
-
     fun alias(alias: String) = AliasedBucket(name, alias, scope)
 
     fun withScope(scopeName: String) = copy(scope = BucketScope(scopeName))
@@ -36,23 +34,16 @@ data class UnaliasedBucket(
         copy(scope = BucketScope(scopeName, ScopeCollection(collectionName)))
 }
 
-data class AliasedBucket(
+open class AliasedBucket(
     override val name: String,
     val alias: String,
     override val scope: BucketScope? = null,
 ) : Bucket {
-    fun asBucketDefinition(): AliasedBucketDefinition =
-        AliasedBucketDefinition(
-            bucketName = name,
-            scopeName = scope?.name,
-            collectionName = scope?.collection?.name,
-            alias = alias,
-        )
+    open fun asBucketDefinition(): Resolvable = AliasedBucketDefinition(name, alias, scope)
 }
 
 data class AliasedBucketDefinition(
     val bucketName: String,
-    val scopeName: String? = null,
-    val collectionName: String? = null,
     val alias: String,
+    val scope: BucketScope? = null,
 ) : Resolvable

couchbase/build.gradle.kts

@@ -35,6 +35,8 @@ repositories {
 dependencies {
     implementation(project(":core"))
     testImplementation(kotlin("test"))
+    testImplementation(platform("org.junit:junit-bom:5.10.2"))
+    testImplementation("org.junit.jupiter:junit-jupiter")
     testImplementation("com.couchbase.client:kotlin-client:1.5.0")
     testImplementation("org.testcontainers:couchbase:1.21.4")
     implementation(kotlin("reflect"))

couchbase/src/main/kotlin/ch/ergon/dope/couchbase/resolvable/keyspace/SystemBuckets.kt

@@ -0,0 +1,36 @@
+package ch.ergon.dope.couchbase.resolvable.keyspace
+
+object SystemBuckets {
+    val datastoresBucket: DatastoresBucket = DatastoresBucket()
+    val namespacesBucket: NamespacesBucket = NamespacesBucket()
+    val bucketsBucket: BucketsBucket = BucketsBucket()
+    val scopesBucket: ScopesBucket = ScopesBucket()
+    val keyspacesBucket: KeyspacesBucket = KeyspacesBucket()
+    val indexesBucket: IndexesBucket = IndexesBucket()
+    val dualBucket: DualBucket = DualBucket()
+    val groupInfoBucket: GroupInfoBucket = GroupInfoBucket()
+    val bucketInfoBucket: BucketInfoBucket = BucketInfoBucket()
+
+    val vitalsBucket: VitalsBucket = VitalsBucket()
+    val activeRequestsBucket: ActiveRequestsBucket = ActiveRequestsBucket()
+    val preparedsBucket: PreparedsBucket = PreparedsBucket()
+    val completedRequestsBucket: CompletedRequestsBucket = CompletedRequestsBucket()
+    val completedRequestsHistoryBucket: CompletedRequestsHistoryBucket = CompletedRequestsHistoryBucket()
+    val awrBucket: AwrBucket = AwrBucket()
+
+    val myUserInfoBucket: MyUserInfoBucket = MyUserInfoBucket()
+    val userInfoBucket: UserInfoBucket = UserInfoBucket()
+    val nodesBucket: NodesBucket = NodesBucket()
+    val applicableRolesBucket: ApplicableRolesBucket = ApplicableRolesBucket()
+
+    val dictionaryBucket: DictionaryBucket = DictionaryBucket()
+    val dictionaryCacheBucket: DictionaryCacheBucket = DictionaryCacheBucket()
+    val functionsBucket: FunctionsBucket = FunctionsBucket()
+    val functionsCacheBucket: FunctionsCacheBucket = FunctionsCacheBucket()
+    val tasksCacheBucket: TasksCacheBucket = TasksCacheBucket()
+    val transactionsBucket: TransactionsBucket = TransactionsBucket()
+    val sequencesBucket: SequencesBucket = SequencesBucket()
+    val allSequencesBucket: AllSequencesBucket = AllSequencesBucket()
+    val ausBucket: AusBucket = AusBucket()
+    val ausSettingsBucket: AusSettingsBucket = AusSettingsBucket()
+}

couchbase/src/main/kotlin/ch/ergon/dope/couchbase/resolver/KeySpaceResolver.kt

@@ -8,17 +8,14 @@ import ch.ergon.dope.couchbase.util.formatToQueryStringWithSymbol
 import ch.ergon.dope.resolvable.bucket.AliasedBucket
 import ch.ergon.dope.resolvable.bucket.AliasedBucketDefinition
 import ch.ergon.dope.resolvable.bucket.IndexReference
+import ch.ergon.dope.resolvable.bucket.UnaliasedBucket
 import ch.ergon.dope.resolvable.bucket.UseIndex
 import ch.ergon.dope.resolvable.bucket.UseKeysClass
 
 interface KeySpaceResolver : AbstractCouchbaseResolver {
     fun resolve(aliasedBucket: AliasedBucketDefinition): CouchbaseDopeQuery =
         CouchbaseDopeQuery(
-            formatBucket(
-                aliasedBucket.bucketName,
-                aliasedBucket.scopeName,
-                aliasedBucket.collectionName,
-            ) + " AS `${aliasedBucket.alias}`",
+            formatBucket(UnaliasedBucket(aliasedBucket.bucketName, aliasedBucket.scope)) + " AS `${aliasedBucket.alias}`",
         )
 
     fun resolve(useKeysClass: UseKeysClass): CouchbaseDopeQuery {

couchbase/src/main/kotlin/ch/ergon/dope/couchbase/util/QueryStringBuilder.kt

@@ -25,14 +25,14 @@ internal fun formatPathToQueryString(name: String, path: String) =
     }
 
 internal fun formatBucket(bucket: Bucket): String =
-    bucket.name.split('.').plus(listOfNotNull(bucket.scope?.name, bucket.scope?.collection?.name))
+    bucket.name.split(".").plus(listOfNotNull(bucket.scope?.name, bucket.scope?.collection?.name))
         .filter { it.isNotBlank() }
-        .joinToString(".") { "`$it`" }
-
-internal fun formatBucket(bucket: String, scope: String? = null, collection: String? = null): String =
-    listOfNotNull(bucket, scope, collection)
-        .filter { it.isNotBlank() }
-        .joinToString(".") { "`$it`" }
+        .joinToString(".") { dotPart ->
+            dotPart
+                .split(':')
+                .filter { it.isNotBlank() }
+                .joinToString(":") { "`$it`" }
+        }
 
 internal fun formatPartsToQueryStringWithSpace(vararg string: String?) =
     listOfNotNull(*string).joinToString(separator = " ")