Merge branch 'main' into perf/defer-watcher-dependent-keys

Author: BoD

CHANGELOG.md

@@ -2,9 +2,12 @@
 
 - [Improvement] Derive the keys a watcher matches cache changes against lazily, keeping the re-normalization of the whole response off the path that delivers the initial responses of `watch` (#378)
 - [Improvement] Reduce allocations when deriving a watcher's dependent keys and matching them against a cache change (#378)
+- Enable parallel sync for Tooling API clients (#380)
 
 PUT_CHANGELOG_HERE
 
+- [Fix] `SqlNormalizedCacheFactory()` no longer touches the disk when called, fixing a StrictMode main thread disk read. The driver is now created in `NormalizedCacheFactory.create()` (#373)
+
 # v1.0.6
 _2026-07-17_
 

gradle.properties

@@ -4,5 +4,6 @@ android.useAndroidX=true
 
 org.gradle.caching=true
 org.gradle.parallel=true
+org.gradle.tooling.parallel=true
 
 kotlin.stdlib.default.dependency=false

normalized-cache-sqlite/src/androidMain/kotlin/com/apollographql/cache/normalized/sql/SqlNormalizedCacheFactory.android.kt

@@ -7,7 +7,9 @@ import androidx.sqlite.db.framework.FrameworkSQLiteOpenHelperFactory
 import app.cash.sqldelight.async.coroutines.synchronous
 import app.cash.sqldelight.driver.android.AndroidSqliteDriver
 import com.apollographql.apollo.exception.apolloExceptionHandler
+import com.apollographql.cache.normalized.api.NormalizedCache
 import com.apollographql.cache.normalized.api.NormalizedCacheFactory
+import com.apollographql.cache.normalized.sql.internal.RecordDatabase
 import com.apollographql.cache.normalized.sql.internal.record.SqlRecordDatabase
 
 actual fun SqlNormalizedCacheFactory(name: String?): NormalizedCacheFactory =
@@ -30,50 +32,50 @@ fun SqlNormalizedCacheFactory(
     configure: ((SupportSQLiteDatabase) -> Unit)? = null,
     useNoBackupDirectory: Boolean = false,
     windowSizeBytes: Long? = 4 * 1024 * 1024,
-): NormalizedCacheFactory {
-  val synchronousSchema = SqlRecordDatabase.Schema.synchronous()
-  val filePath = when {
-    name == null -> {
-      null
-    }
+): NormalizedCacheFactory = object : NormalizedCacheFactory() {
+  override fun create(): NormalizedCache {
+    val synchronousSchema = SqlRecordDatabase.Schema.synchronous()
+    val filePath = when {
+      name == null -> {
+        null
+      }
 
-    name.startsWith("/") -> {
-      // Absolute path: keep as-is
-      name
-    }
+      name.startsWith("/") -> {
+        // Absolute path: keep as-is
+        name
+      }
 
-    else -> {
-      // Old versions of the library used to store the database in the database directory.
-      // If such file exists, use it, otherwise, use the cache directory.
-      (context.getDatabasePath(name).takeIf { it.exists() } ?: context.cacheDir.resolve(name)).absolutePath
+      else -> {
+        // Old versions of the library used to store the database in the database directory.
+        // If such file exists, use it, otherwise, use the cache directory.
+        (context.getDatabasePath(name).takeIf { it.exists() } ?: context.cacheDir.resolve(name)).absolutePath
+      }
     }
-  }
-  return SqlNormalizedCacheFactory(
-      driver = AndroidSqliteDriver(
-          schema = synchronousSchema,
-          context = context.applicationContext,
-          name = filePath,
-          factory = factory,
-          callback = object : AndroidSqliteDriver.Callback(synchronousSchema) {
-            override fun onConfigure(db: SupportSQLiteDatabase) {
-              super.onConfigure(db)
-              configure?.invoke(db)
-            }
+    val driver = AndroidSqliteDriver(
+        schema = synchronousSchema,
+        context = context.applicationContext,
+        name = filePath,
+        factory = factory,
+        callback = object : AndroidSqliteDriver.Callback(synchronousSchema) {
+          override fun onConfigure(db: SupportSQLiteDatabase) {
+            super.onConfigure(db)
+            configure?.invoke(db)
+          }
 
-            override fun onCorruption(db: SupportSQLiteDatabase) {
-              apolloExceptionHandler(Exception("Corruption detected, recreating the database"))
-              super.onCorruption(db)
-            }
+          override fun onCorruption(db: SupportSQLiteDatabase) {
+            apolloExceptionHandler(Exception("Corruption detected, recreating the database"))
+            super.onCorruption(db)
+          }
 
-            override fun onDowngrade(db: SupportSQLiteDatabase, oldVersion: Int, newVersion: Int) {
-              // Treat downgrades as corruption, which results in a clean database
-              apolloExceptionHandler(Exception("onDowngrade from $oldVersion to $newVersion, treating as database corruption"))
-              super.onCorruption(db)
-            }
-          },
-          useNoBackupDirectory = useNoBackupDirectory,
-          windowSizeBytes = windowSizeBytes,
-      ),
-      name = filePath,
-  )
+          override fun onDowngrade(db: SupportSQLiteDatabase, oldVersion: Int, newVersion: Int) {
+            // Treat downgrades as corruption, which results in a clean database
+            apolloExceptionHandler(Exception("onDowngrade from $oldVersion to $newVersion, treating as database corruption"))
+            super.onCorruption(db)
+          }
+        },
+        useNoBackupDirectory = useNoBackupDirectory,
+        windowSizeBytes = windowSizeBytes,
+    )
+    return SqlNormalizedCache(RecordDatabase(driver, filePath))
+  }
 }

normalized-cache-sqlite/src/appleMain/kotlin/com/apollographql/cache/normalized/sql/SqlNormalizedCacheFactory.apple.kt

@@ -5,7 +5,9 @@ import app.cash.sqldelight.db.SqlDriver
 import app.cash.sqldelight.driver.native.NativeSqliteDriver
 import app.cash.sqldelight.driver.native.wrapConnection
 import co.touchlab.sqliter.DatabaseConfiguration
+import com.apollographql.cache.normalized.api.NormalizedCache
 import com.apollographql.cache.normalized.api.NormalizedCacheFactory
+import com.apollographql.cache.normalized.sql.internal.RecordDatabase
 import com.apollographql.cache.normalized.sql.internal.record.SqlRecordDatabase
 
 /**
@@ -17,7 +19,11 @@ import com.apollographql.cache.normalized.sql.internal.record.SqlRecordDatabase
 fun SqlNormalizedCacheFactory(
     name: String?,
     baseDir: String?,
-): NormalizedCacheFactory = SqlNormalizedCacheFactory(createDriver(name, baseDir), name)
+): NormalizedCacheFactory = object : NormalizedCacheFactory() {
+  override fun create(): NormalizedCache {
+    return SqlNormalizedCache(RecordDatabase(createDriver(name, baseDir), name))
+  }
+}
 
 actual fun SqlNormalizedCacheFactory(name: String?): NormalizedCacheFactory = SqlNormalizedCacheFactory(name, null)
 

normalized-cache-sqlite/src/jsCommonMain/kotlin/com/apollographql/cache/normalized/sql/SqlNormalizedCacheFactory.jsCommon.kt

@@ -1,7 +1,9 @@
 package com.apollographql.cache.normalized.sql
 
 import app.cash.sqldelight.driver.worker.createDefaultWebWorkerDriver
+import com.apollographql.cache.normalized.api.NormalizedCache
 import com.apollographql.cache.normalized.api.NormalizedCacheFactory
+import com.apollographql.cache.normalized.sql.internal.RecordDatabase
 
 /**
  * Returns a SqlNormalizedCacheFactory configured with the default driver which works with SQL.js.
@@ -14,7 +16,9 @@ import com.apollographql.cache.normalized.api.NormalizedCacheFactory
  *
  * See [the SQLDelight documentation](https://sqldelight.github.io/sqldelight/2.1.0/js_sqlite/sqljs_worker/).
  */
-actual fun SqlNormalizedCacheFactory(name: String?): NormalizedCacheFactory {
-  return SqlNormalizedCacheFactory(createDefaultWebWorkerDriver(), name = null)
+actual fun SqlNormalizedCacheFactory(name: String?): NormalizedCacheFactory = object : NormalizedCacheFactory() {
+  override fun create(): NormalizedCache {
+    return SqlNormalizedCache(RecordDatabase(createDefaultWebWorkerDriver(), name = null))
+  }
 }
 

normalized-cache-sqlite/src/jvmMain/kotlin/com/apollographql/cache/normalized/sql/SqlNormalizedCacheFactory.jvm.kt

@@ -1,7 +1,9 @@
 package com.apollographql.cache.normalized.sql
 
 import app.cash.sqldelight.driver.jdbc.sqlite.JdbcSqliteDriver
+import com.apollographql.cache.normalized.api.NormalizedCache
 import com.apollographql.cache.normalized.api.NormalizedCacheFactory
+import com.apollographql.cache.normalized.sql.internal.RecordDatabase
 import java.io.File
 import java.util.Properties
 
@@ -13,7 +15,11 @@ import java.util.Properties
 fun SqlNormalizedCacheFactory(
     url: String,
     properties: Properties,
-): NormalizedCacheFactory = SqlNormalizedCacheFactory(JdbcSqliteDriver(url, properties), name = null)
+): NormalizedCacheFactory = object : NormalizedCacheFactory() {
+  override fun create(): NormalizedCache {
+    return SqlNormalizedCache(RecordDatabase(JdbcSqliteDriver(url, properties), name = null))
+  }
+}
 
 /**
  * @param name the name of the database or null for an in-memory database
@@ -24,7 +30,11 @@ fun SqlNormalizedCacheFactory(
 fun SqlNormalizedCacheFactory(
     name: String?,
     baseDir: String?,
-): NormalizedCacheFactory = SqlNormalizedCacheFactory(JdbcSqliteDriver(name.toUrl(baseDir), Properties()), name = name)
+): NormalizedCacheFactory = object : NormalizedCacheFactory() {
+  override fun create(): NormalizedCache {
+    return SqlNormalizedCache(RecordDatabase(JdbcSqliteDriver(name.toUrl(baseDir), Properties()), name = name))
+  }
+}
 
 actual fun SqlNormalizedCacheFactory(name: String?): NormalizedCacheFactory = SqlNormalizedCacheFactory(name, null)
 

normalized-cache-sqlite/src/jvmTest/kotlin/com/apollographql/cache/normalized/sql/JvmSqlNormalizedCacheTest.kt

@@ -11,11 +11,30 @@ import com.apollographql.cache.normalized.api.DefaultRecordMerger
 import com.apollographql.cache.normalized.api.Record
 import com.apollographql.cache.normalized.sql.internal.RecordDatabase
 import com.apollographql.cache.normalized.testing.runTest
+import java.io.File
 import java.util.Properties
 import kotlin.test.Test
 import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
 
 class JvmSqlNormalizedCacheTest {
+  @Test
+  fun theDatabaseIsNotCreatedUntilTheCacheIs() {
+    val baseDir = File(System.getProperty("java.io.tmpdir"), "apollo-test-${System.nanoTime()}")
+    try {
+      val factory = SqlNormalizedCacheFactory(name = "test.db", baseDir = baseDir.path)
+
+      // Creating the factory must not touch the disk.
+      assertFalse(baseDir.exists(), "The base directory must not be created before NormalizedCacheFactory.create()")
+
+      factory.create()
+      assertTrue(baseDir.exists(), "The base directory must be created by NormalizedCacheFactory.create()")
+    } finally {
+      baseDir.deleteRecursively()
+    }
+  }
+
   @Test
   fun mergingIdenticalRecordIsANoOp() = runTest {
     val driver = SpyDriver(JdbcSqliteDriver(JdbcSqliteDriver.IN_MEMORY, Properties()))

normalized-cache/src/commonMain/kotlin/com/apollographql/cache/normalized/internal/DefaultCacheManager.kt

@@ -141,8 +141,8 @@ internal class DefaultCacheManager(
       customScalarAdapters: CustomScalarAdapters,
       cacheHeaders: CacheHeaders,
   ): ApolloResponse<D> {
-    val cacheMissesAsException = cacheHeaders.headerValue(ApolloCacheHeaders.CACHE_MISSES_AS_EXCEPTION) == "true"
-    val serverErrorsAsException = cacheHeaders.headerValue(ApolloCacheHeaders.SERVER_ERRORS_AS_EXCEPTION) == "true"
+    val cacheMissesAsException = (cacheHeaders.headerValue(ApolloCacheHeaders.CACHE_MISSES_AS_EXCEPTION) ?: "true") == "true"
+    val serverErrorsAsException = (cacheHeaders.headerValue(ApolloCacheHeaders.SERVER_ERRORS_AS_EXCEPTION) ?: "true") == "true"
     val variables = operation.variables(customScalarAdapters, true)
     val batchReaderData =
       try {

normalized-cache/src/commonMain/kotlin/com/apollographql/cache/normalized/options/cacheHeaders.kt

@@ -15,25 +15,20 @@ internal class CacheHeadersContext(val value: CacheHeaders) : ExecutionContext.E
   override val key: ExecutionContext.Key<*>
     get() = Key
 
+  /**
+   * Merge the [CacheHeaders] instead of letting the right element replace the right element.
+   */
+  override fun <R> fold(initial: R, operation: (R, ExecutionContext.Element) -> R): R {
+    val existing = (initial as? ExecutionContext)?.get(Key)
+    val element = if (existing != null) CacheHeadersContext(existing.value + value) else this
+    return operation(initial, element)
+  }
+
   companion object Key : ExecutionContext.Key<CacheHeadersContext>
 }
 
 internal val ExecutionOptions.cacheHeaders: CacheHeaders
-  get() = (executionContext[CacheHeadersContext]?.value ?: CacheHeaders.NONE).withDefaultValues
-
-private val CacheHeaders.withDefaultValues: CacheHeaders
-  get() = newBuilder()
-      .apply {
-        // Apply values for ExecutionOptions.cacheMissesAsException and ExecutionOptions.serverErrorsAsException
-        // which are true by default contrary to other flags.
-        if (!hasHeader(ApolloCacheHeaders.CACHE_MISSES_AS_EXCEPTION)) {
-          addHeader(ApolloCacheHeaders.CACHE_MISSES_AS_EXCEPTION, "true")
-        }
-        if (!hasHeader(ApolloCacheHeaders.SERVER_ERRORS_AS_EXCEPTION)) {
-          addHeader(ApolloCacheHeaders.SERVER_ERRORS_AS_EXCEPTION, "true")
-        }
-      }
-      .build()
+  get() = (executionContext[CacheHeadersContext]?.value ?: CacheHeaders.NONE)
 
 fun <D : Operation.Data> ApolloResponse.Builder<D>.cacheHeaders(cacheHeaders: CacheHeaders) =
   addExecutionContext(CacheHeadersContext(cacheHeaders))

test-utils/src/commonMain/kotlin/com/apollographql/cache/normalized/testing/noExceptionsHeaders.kt

@@ -0,0 +1,9 @@
+package com.apollographql.cache.normalized.testing
+
+import com.apollographql.cache.normalized.api.ApolloCacheHeaders
+import com.apollographql.cache.normalized.api.CacheHeaders
+
+val noExceptionsHeaders = CacheHeaders.Builder()
+    .addHeader(ApolloCacheHeaders.CACHE_MISSES_AS_EXCEPTION, "false")
+    .addHeader(ApolloCacheHeaders.SERVER_ERRORS_AS_EXCEPTION, "false")
+    .build()