Review feedback

Author: simolus3

core/src/commonMain/kotlin/com/powersync/PowerSyncDatabase.kt

@@ -217,18 +217,30 @@ public interface PowerSyncDatabase : Queries {
          * In this case, PowerSync will not open its own SQLite connections, but rather refer to
          * connections in the [pool].
          *
-         * The `group` parameter should likely be teh result of calling [databaseGroup] - this is
-         * responsible for ensuring two instances of the same database file don't sync at the same
-         * time. So, a value that uniquely identifies the database should be passed to
-         * [databaseGroup].
+         * The `identifier` parameter should be a name identifying the path of the database. The
+         * PowerSync SDK will emit a warning if multiple databases are opened with the same
+         * identifier, and uses internal locks to ensure these two databases are not synced at the
+         * same time (which would be inefficient and can cause consistency issues).
          */
         @ExperimentalPowerSyncAPI
         public fun opened(
             pool: SQLiteConnectionPool,
             scope: CoroutineScope,
             schema: Schema,
-            group: Pair<ActiveDatabaseResource, Any>,
+            identifier: String,
             logger: Logger,
+        ): PowerSyncDatabase {
+            val group = ActiveDatabaseGroup.referenceDatabase(logger, identifier)
+            return openedWithGroup(pool, scope, schema, logger, group)
+        }
+
+        @ExperimentalPowerSyncAPI
+        internal fun openedWithGroup(
+            pool: SQLiteConnectionPool,
+            scope: CoroutineScope,
+            schema: Schema,
+            logger: Logger,
+            group: Pair<ActiveDatabaseResource, Any>,
         ): PowerSyncDatabase =
             PowerSyncDatabaseImpl(
                 schema,
@@ -237,11 +249,5 @@ public interface PowerSyncDatabase : Queries {
                 logger,
                 group,
             )
-
-        @ExperimentalPowerSyncAPI
-        public fun databaseGroup(
-            logger: Logger,
-            identifier: String,
-        ): Pair<ActiveDatabaseResource, Any> = ActiveDatabaseGroup.referenceDatabase(logger, identifier)
     }
 }

core/src/commonMain/kotlin/com/powersync/PowerSyncDatabaseFactory.kt

@@ -66,11 +66,11 @@ internal fun createPowerSyncDatabaseImpl(
             )
         }
 
-    return PowerSyncDatabase.opened(
+    return PowerSyncDatabase.openedWithGroup(
         pool,
         scope,
         schema,
-        activeDatabaseGroup,
         logger,
+        activeDatabaseGroup,
     ) as PowerSyncDatabaseImpl
 }

core/src/commonMain/kotlin/com/powersync/db/ActiveInstanceStore.kt

@@ -82,12 +82,12 @@ internal class ActiveDatabaseGroup(
     }
 }
 
-public class ActiveDatabaseResource internal constructor(
-    internal val group: ActiveDatabaseGroup,
+internal class ActiveDatabaseResource(
+    val group: ActiveDatabaseGroup,
 ) {
-    internal val disposed = AtomicBoolean(false)
+    val disposed = AtomicBoolean(false)
 
-    internal fun dispose() {
+    fun dispose() {
         if (disposed.compareAndSet(false, true)) {
             group.removeUsage()
         }