@livestore/adapter-web 0.4.0-dev.5 → 0.4.0-dev.7

package/src/web-worker/common/persisted-sqlite.ts

@@ -1,12 +1,13 @@
 import { liveStoreStorageFormatVersion, UnexpectedError } from '@livestore/common'
 import type { LiveStoreSchema } from '@livestore/common/schema'
-import { decodeSAHPoolFilename, HEADER_OFFSET_DATA } from '@livestore/sqlite-wasm/browser'
+import { decodeSAHPoolFilename, HEADER_OFFSET_DATA, type WebDatabaseMetadataOpfs } from '@livestore/sqlite-wasm/browser'
 import { Effect, Schedule, Schema } from '@livestore/utils/effect'
 
 import * as OpfsUtils from '../../opfs-utils.ts'
 import type * as WorkerSchema from './worker-schema.ts'
 
 export class PersistedSqliteError extends Schema.TaggedError<PersistedSqliteError>()('PersistedSqliteError', {
+  message: Schema.String,
   cause: Schema.Defect,
 }) {}
 
@@ -141,3 +142,78 @@ export const getStateDbFileName = (schema: LiveStoreSchema) => {
     schema.state.sqlite.migrations.strategy === 'manual' ? 'fixed' : schema.state.sqlite.hash.toString()
   return `state${schemaHashSuffix}.db`
 }
+
+/**
+ * Cleanup old state database files after successful migration.
+ * This prevents OPFS file pool capacity from being exhausted by accumulated schema files.
+ *
+ * @param vfs - The AccessHandlePoolVFS instance for safe file operations
+ * @param currentSchema - Current schema (to avoid deleting the active database)
+ */
+export const cleanupOldStateDbFiles = Effect.fn('@livestore/adapter-web:cleanupOldStateDbFiles')(
+  function* ({ vfs, currentSchema }: { vfs: WebDatabaseMetadataOpfs['vfs']; currentSchema: LiveStoreSchema }) {
+    // Only cleanup for auto migration strategy because:
+    // - Auto strategy: Creates new database files per schema change (e.g., state123.db, state456.db)
+    //   which accumulate over time and can exhaust OPFS file pool capacity
+    // - Manual strategy: Always reuses the same database file (statefixed.db) across schema changes,
+    //   so there are never multiple old files to clean up
+    if (currentSchema.state.sqlite.migrations.strategy === 'manual') {
+      yield* Effect.logDebug('Skipping state db cleanup - manual migration strategy uses fixed filename')
+      return
+    }
+
+    const currentDbFileName = getStateDbFileName(currentSchema)
+    const currentPath = `/${currentDbFileName}`
+
+    const allPaths = yield* Effect.sync(() => vfs.getTrackedFilePaths())
+    const oldStateDbPaths = allPaths.filter(
+      (path) => path.startsWith('/state') && path.endsWith('.db') && path !== currentPath,
+    )
+
+    if (oldStateDbPaths.length === 0) {
+      yield* Effect.logDebug('State db cleanup completed: no old database files found')
+      return
+    }
+
+    yield* Effect.logDebug(`Found ${oldStateDbPaths.length} old state database file(s) to clean up`)
+
+    let deletedCount = 0
+    for (const path of oldStateDbPaths) {
+      const fileName = path.startsWith('/') ? path.slice(1) : path
+
+      const vfsResultCode = yield* Effect.try({
+        try: () => vfs.jDelete(fileName, 0),
+        catch: (cause) => new SqliteVfsError({ operation: 'jDelete', fileName, cause }),
+      })
+
+      // 0 indicates a successful result in SQLite.
+      // See https://www.sqlite.org/c3ref/c_abort.html
+      if (vfsResultCode !== 0) {
+        return yield* new SqliteVfsError({
+          operation: 'jDelete',
+          fileName,
+          vfsResultCode,
+        })
+      }
+
+      deletedCount++
+      yield* Effect.logDebug(`Successfully deleted old state database file: ${fileName}`)
+    }
+
+    yield* Effect.logDebug(`State db cleanup completed: removed ${deletedCount} old database file(s)`)
+  },
+  Effect.mapError(
+    (error) =>
+      new PersistedSqliteError({
+        message: 'Failed to clean up old state database file(s)',
+        cause: error,
+      }),
+  ),
+)
+
+export class SqliteVfsError extends Schema.TaggedError<SqliteVfsError>()('SqliteVfsError', {
+  operation: Schema.String,
+  fileName: Schema.String,
+  vfsResultCode: Schema.optional(Schema.Number),
+  cause: Schema.optional(Schema.Defect),
+}) {}

package/src/web-worker/leader-worker/make-leader-worker.ts

@@ -26,7 +26,7 @@ import {
 import type * as otel from '@opentelemetry/api'
 
 import * as OpfsUtils from '../../opfs-utils.ts'
-import { getStateDbFileName, sanitizeOpfsDir } from '../common/persisted-sqlite.ts'
+import { cleanupOldStateDbFiles, getStateDbFileName, sanitizeOpfsDir } from '../common/persisted-sqlite.ts'
 import { makeShutdownChannel } from '../common/shutdown-channel.ts'
 import * as WorkerSchema from '../common/worker-schema.ts'
 
@@ -131,6 +131,15 @@ const makeWorkerRunnerInner = ({ schema, sync: syncOptions }: WorkerOptions) =>
           concurrency: 2,
         })
 
+        // Clean up old state database files after successful database creation
+        // This prevents OPFS file pool capacity exhaustion from accumulated state db files after schema changes/migrations
+        if (dbState.metadata._tag === 'opfs') {
+          yield* cleanupOldStateDbFiles({
+            vfs: dbState.metadata.vfs,
+            currentSchema: schema,
+          })
+        }
+
         const devtoolsOptions = yield* makeDevtoolsOptions({ devtoolsEnabled, dbState, dbEventlog })
         const shutdownChannel = yield* makeShutdownChannel(storeId)
 

package/src/web-worker/shared-worker/make-shared-worker.ts

@@ -28,6 +28,20 @@ import {
 import { makeShutdownChannel } from '../common/shutdown-channel.ts'
 import * as WorkerSchema from '../common/worker-schema.ts'
 
+// Extract from `livestore-shared-worker-${storeId}`
+const storeId = self.name.replace('livestore-shared-worker-', '')
+
+// We acquire a lock that is held as long as this shared worker is alive.
+// This way, when the shared worker is terminated (e.g. by the browser when the page is closed),
+// the lock is released and any thread waiting for the lock can be notified.
+const LIVESTORE_SHARED_WORKER_TERMINATION_LOCK = `livestore-shared-worker-termination-lock-${storeId}`
+navigator.locks.request(
+  LIVESTORE_SHARED_WORKER_TERMINATION_LOCK,
+  { steal: true },
+  // We use a never-resolving promise to hold the lock
+  async () => new Promise(() => {}),
+)
+
 if (isDevEnv()) {
   globalThis.__debugLiveStoreUtils = {
     blobUrl: (buffer: Uint8Array<ArrayBuffer>) =>
@@ -241,9 +255,6 @@ const makeWorkerRunner = Effect.gen(function* () {
 }).pipe(Layer.unwrapScoped)
 
 export const makeWorker = () => {
-  // Extract from `livestore-shared-worker-${storeId}`
-  const storeId = self.name.replace('livestore-shared-worker-', '')
-
   makeWorkerRunner.pipe(
     Layer.provide(BrowserWorkerRunner.layer),
     // WorkerRunner.launch,