add IndexedDbSessionDatabase fallback

Author: bourgeoa

jest.config.mjs

@@ -13,6 +13,7 @@ export default {
   },
   moduleNameMapper: {
     '^@uvdsl/solid-oidc-client-browser$': '<rootDir>/test/mocks/solid-oidc-client-browser.ts',
+    '^@uvdsl/solid-oidc-client-browser/core$': '<rootDir>/test/mocks/solid-oidc-client-browser.ts',
   },
   setupFilesAfterEnv: ['./test/helpers/setup.ts'],
   testMatch: ['**/__tests__/**/*.ts?(x)', '**/?(*.)+(spec|test).ts?(x)'],

src/authSession/authSession.ts

@@ -1,6 +1,10 @@
 import {
-  Session,
+  Session as WebSession,
 } from '@uvdsl/solid-oidc-client-browser'
+import {
+  SessionCore,
+} from '@uvdsl/solid-oidc-client-browser/core'
+import type { Session as OidcSession, SessionDatabase } from '@uvdsl/solid-oidc-client-browser/core'
 
 type LegacyEventName = 'login' | 'logout' | 'sessionRestore'
 type LegacyEventHandler = (...args: unknown[]) => void
@@ -30,9 +34,137 @@ export class SessionEvents {
   }
 }
 
-export type SessionWithLegacyEvents = Session & { events: SessionEvents }
+type SessionCompatibilityShape = {
+  webId?: string
+  isActive?: boolean
+  info?: {
+    webId?: string
+    isLoggedIn?: boolean
+  }
+  fetch?: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>
+  authFetch?: (input: string | URL | Request, init?: RequestInit, dpopPayload?: any) => Promise<Response>
+}
+
+export type SessionWithLegacyEvents = OidcSession & SessionCompatibilityShape & { events: SessionEvents }
+
+class MemorySessionDatabase implements SessionDatabase {
+  private readonly map = new Map<string, any>()
+
+  async init (): Promise<SessionDatabase> {
+    return this
+  }
+
+  async setItem (id: string, value: any): Promise<void> {
+    this.map.set(id, value)
+  }
+
+  async getItem (id: string): Promise<any> {
+    return this.map.has(id) ? this.map.get(id) : null
+  }
+
+  async deleteItem (id: string): Promise<void> {
+    this.map.delete(id)
+  }
+
+  async clear (): Promise<void> {
+    this.map.clear()
+  }
+
+  close (): void {
+    // No-op for in-memory database
+  }
+}
+
+class IndexedDbSessionDatabase implements SessionDatabase {
+  private db: IDBDatabase | null = null
+  private readonly dbName = 'soidc'
+  private readonly storeName = 'session'
+  private readonly dbVersion = 1
+
+  async init (): Promise<SessionDatabase> {
+    if (this.db) return this
+
+    await new Promise<void>((resolve, reject) => {
+      const request = indexedDB.open(this.dbName, this.dbVersion)
+
+      request.onerror = () => reject(request.error)
+      request.onsuccess = () => {
+        this.db = request.result
+        resolve()
+      }
+      request.onupgradeneeded = () => {
+        const db = request.result
+        if (!db.objectStoreNames.contains(this.storeName)) {
+          db.createObjectStore(this.storeName)
+        }
+      }
+    })
+
+    return this
+  }
+
+  async setItem (id: string, value: any): Promise<void> {
+    await this.init()
+    await this.withStore('readwrite', store => store.put(value, id))
+  }
+
+  async getItem (id: string): Promise<any> {
+    await this.init()
+    return this.withStore('readonly', store => store.get(id))
+  }
+
+  async deleteItem (id: string): Promise<void> {
+    await this.init()
+    await this.withStore('readwrite', store => store.delete(id))
+  }
+
+  async clear (): Promise<void> {
+    await this.init()
+    await this.withStore('readwrite', store => store.clear())
+  }
+
+  close (): void {
+    if (this.db) {
+      this.db.close()
+      this.db = null
+    }
+  }
+
+  private withStore(mode: IDBTransactionMode, op: (store: IDBObjectStore) => IDBRequest<any>): Promise<any> {
+    return new Promise<any>((resolve, reject) => {
+      if (!this.db) {
+        reject(new Error('Session database not initialized'))
+        return
+      }
+
+      const tx = this.db.transaction(this.storeName, mode)
+      const store = tx.objectStore(this.storeName)
+      const request = op(store)
+
+      request.onerror = () => reject(request.error)
+      request.onsuccess = () => resolve(request.result ?? null)
+    })
+  }
+}
+
+function createSession (): OidcSession {
+  try {
+    return new WebSession()
+  } catch (error) {
+    // In some deployments, worker URL resolution can become file:// and fail cross-origin.
+    // Fall back to SessionCore so auth still works without background refresh worker.
+    // Use IndexedDB to keep refresh-token persistence across page reloads.
+    console.warn('solid-logic: falling back to non-worker auth session:', error)
+    try {
+      return new SessionCore(undefined, { database: new IndexedDbSessionDatabase() })
+    } catch (dbError) {
+      console.warn('solid-logic: IndexedDB unavailable, using in-memory session database:', dbError)
+      return new SessionCore(undefined, { database: new MemorySessionDatabase() })
+    }
+  }
+}
 
-const _session = new Session()
+const _session = createSession()
 const events = new SessionEvents()
 
 // Emit the legacy 'logout' event when the session transitions from active to inactive.

test/mocks/solid-oidc-client-browser.ts

@@ -51,3 +51,35 @@ export class Session {
     return globalThis.fetch(input, init)
   }
 }
+
+export class SessionCore extends Session {
+  constructor(_clientDetails?: unknown, _sessionOptions?: unknown) {
+    super()
+  }
+}
+
+export class SessionIDB {
+  async init(): Promise<SessionIDB> {
+    return this
+  }
+
+  async setItem(_id: string, _value: any): Promise<void> {
+    return
+  }
+
+  async getItem(_id: string): Promise<any> {
+    return null
+  }
+
+  async deleteItem(_id: string): Promise<void> {
+    return
+  }
+
+  async clear(): Promise<void> {
+    return
+  }
+
+  close(): void {
+    return
+  }
+}