@livestore/adapter-web 0.4.0-dev.21 → 0.4.0-dev.22

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

@@ -1,4 +1,4 @@
-import type { SqliteDb, SyncOptions } from '@livestore/common'
+import type { BootStatus, BootWarningReason, SqliteDb, SyncOptions } from '@livestore/common'
 import { Devtools, LogConfig, UnknownError } from '@livestore/common'
 import type { DevtoolsOptions, StreamEventsOptions } from '@livestore/common/leader-thread'
 import {
@@ -22,12 +22,12 @@ import {
   Layer,
   OtelTracer,
   Scheduler,
-  type Schema,
+  Schema,
   Stream,
   TaskTracing,
   WorkerRunner,
 } from '@livestore/utils/effect'
-import { BrowserWorkerRunner, Opfs } from '@livestore/utils/effect/browser'
+import { BrowserWorkerRunner, Opfs, WebError } from '@livestore/utils/effect/browser'
 import type * as otel from '@opentelemetry/api'
 
 import { cleanupOldStateDbFiles, getStateDbFileName, sanitizeOpfsDir } from '../common/persisted-sqlite.ts'
@@ -118,13 +118,28 @@ const makeWorkerRunnerInner = ({ schema, sync: syncOptions, syncPayloadSchema }:
       Effect.gen(function* () {
         const sqlite3 = yield* Effect.promise(() => loadSqlite3Wasm())
         const makeSqliteDb = sqliteDbFactory({ sqlite3 })
-        const opfsDirectory = yield* sanitizeOpfsDir(storageOptions.directory, storeId)
         const runtime = yield* Effect.runtime<never>()
 
-        const makeDb = (kind: 'state' | 'eventlog') =>
+        // Check OPFS availability and determine storage mode
+        const opfsCheck = yield* checkOpfsAvailability
+        const useOpfs = opfsCheck === undefined
+
+        // Track boot warning to emit later
+        let bootWarning: BootStatus | undefined
+        if (!useOpfs) {
+          yield* Effect.logWarning(
+            '[@livestore/adapter-web:worker] OPFS unavailable, using in-memory storage',
+            opfsCheck,
+          )
+          bootWarning = { stage: 'warning', ...opfsCheck }
+        }
+
+        const opfsDirectory = useOpfs ? yield* sanitizeOpfsDir(storageOptions.directory, storeId) : undefined
+
+        const makeOpfsDb = (kind: 'state' | 'eventlog') =>
           makeSqliteDb({
             _tag: 'opfs',
-            opfsDirectory,
+            opfsDirectory: opfsDirectory!,
             fileName: kind === 'state' ? getStateDbFileName(schema) : 'eventlog.db',
             configureDb: (db) =>
               configureConnection(db, {
@@ -137,10 +152,17 @@ const makeWorkerRunnerInner = ({ schema, sync: syncOptions, syncPayloadSchema }:
               }).pipe(Effect.provide(runtime), Effect.runSync),
           }).pipe(Effect.acquireRelease((db) => Effect.try(() => db.close()).pipe(Effect.ignoreLogged)))
 
-        // Might involve some async work, so we're running them concurrently
-        const [dbState, dbEventlog] = yield* Effect.all([makeDb('state'), makeDb('eventlog')], {
-          concurrency: 2,
-        })
+        const makeInMemoryDb = () =>
+          makeSqliteDb({
+            _tag: 'in-memory',
+            configureDb: (db) =>
+              configureConnection(db, { foreignKeys: true }).pipe(Effect.provide(runtime), Effect.runSync),
+          }).pipe(Effect.acquireRelease((db) => Effect.try(() => db.close()).pipe(Effect.ignoreLogged)))
+
+        // Use OPFS if available, otherwise fall back to in-memory
+        const [dbState, dbEventlog] = useOpfs
+          ? yield* Effect.all([makeOpfsDb('state'), makeOpfsDb('eventlog')], { concurrency: 2 })
+          : yield* Effect.all([makeInMemoryDb(), makeInMemoryDb()], { 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
@@ -167,6 +189,7 @@ const makeWorkerRunnerInner = ({ schema, sync: syncOptions, syncPayloadSchema }:
           shutdownChannel,
           syncPayloadEncoded,
           syncPayloadSchema,
+          ...(bootWarning !== undefined ? { bootWarning } : {}),
         })
       }).pipe(
         Effect.tapCauseLogPretty,
@@ -301,3 +324,29 @@ const makeDevtoolsOptions = ({
       }),
     }
   })
+
+/**
+ * Attempts to access OPFS and returns a warning if unavailable.
+ *
+ * Common failure scenarios:
+ * - Safari/Firefox private browsing: SecurityError or NotAllowedError
+ * - Permission denied: NotAllowedError
+ * - Quota exceeded: QuotaExceededError
+ */
+const checkOpfsAvailability = Effect.gen(function* () {
+  const opfs = yield* Opfs.Opfs
+  return yield* opfs.getRootDirectoryHandle.pipe(
+    Effect.as(undefined),
+    Effect.catchAll((error) => {
+      const reason: BootWarningReason =
+        Schema.is(WebError.SecurityError)(error) || Schema.is(WebError.NotAllowedError)(error)
+          ? 'private-browsing'
+          : 'storage-unavailable'
+      const message =
+        reason === 'private-browsing'
+          ? 'Storage unavailable in private browsing mode. LiveStore will continue without persistence.'
+          : 'Storage access denied. LiveStore will continue without persistence.'
+      return Effect.succeed({ reason, message } as const)
+    }),
+  )
+})