fix(web): recover from a closed IndexedDB connection

apps/web/src/connection/storage.test.ts

@@ -2,8 +2,8 @@ import {
   ConnectionTransientError,
   PrimaryConnectionTarget,
 } from "@t3tools/client-runtime/connection";
-import { EnvironmentId } from "@t3tools/contracts";
-import { ConnectionCatalogDocument } from "@t3tools/client-runtime/platform";
+import { EnvironmentId, ThreadId } from "@t3tools/contracts";
+import { ConnectionCatalogDocument, Persistence } from "@t3tools/client-runtime/platform";
 import { describe, expect, it } from "@effect/vitest";
 import * as Effect from "effect/Effect";
 import * as Deferred from "effect/Deferred";
@@ -16,6 +16,7 @@ import {
   makeBrowserGitHubRoutingPermissions,
   makeCatalogBackend,
   makeCatalogStore,
+  layer as connectionStorageLayer,
 } from "./storage";
 
 const emptyCatalog = {
@@ -68,7 +69,31 @@ describe("makeCatalogStore", () => {
   );
 });
 
+const fixedHandle = (database: IDBDatabase) => ({
+  get: Effect.succeed(database),
+  invalidate: () => Effect.void,
+});
+
 describe("makeCatalogBackend", () => {
+  it.effect("reports a closed IndexedDB connection as a typed read and write failure", () =>
+    Effect.gen(function* () {
+      vi.stubGlobal("window", {});
+      const database = {
+        transaction: () => {
+          throw new DOMException("The database connection is closing.", "InvalidStateError");
+        },
+      } as unknown as IDBDatabase;
+      const backend = makeCatalogBackend(fixedHandle(database));
+
+      const readError = yield* Effect.flip(backend.read);
+      const writeError = yield* Effect.flip(backend.write("{}"));
+
+      expect(readError).toBeInstanceOf(ConnectionTransientError);
+      expect(readError.message).toContain("The database connection is closing.");
+      expect(writeError).toBeInstanceOf(ConnectionTransientError);
+    }),
+  );
+
   it.effect("fails writes when desktop secure storage declines the catalog", () =>
     Effect.gen(function* () {
       const setConnectionCatalog = vi.fn().mockResolvedValue(false);
@@ -78,7 +103,7 @@ describe("makeCatalogBackend", () => {
           setConnectionCatalog,
         },
       });
-      const backend = makeCatalogBackend({} as IDBDatabase);
+      const backend = makeCatalogBackend(fixedHandle({} as IDBDatabase));
 
       const error = yield* backend.write("{}").pipe(Effect.flip);
 
@@ -103,7 +128,9 @@ describe("makeCatalogBackend", () => {
           },
         }),
       });
-      const backend = makeCatalogBackend({ transaction: () => transaction } as never);
+      const backend = makeCatalogBackend(
+        fixedHandle({ transaction: () => transaction } as unknown as IDBDatabase),
+      );
 
       const error = yield* backend.write("{}").pipe(Effect.flip);
 
@@ -112,6 +139,174 @@ describe("makeCatalogBackend", () => {
   );
 });
 
+describe("environment cache removal", () => {
+  it.effect("fails both removal operations when IndexedDB aborts their commits", () =>
+    Effect.gen(function* () {
+      vi.stubGlobal("window", {});
+      vi.stubGlobal("IDBKeyRange", { bound: () => ({}) });
+      const database = Object.assign(new EventTarget(), {
+        transaction: () => {
+          const transaction = Object.assign(new EventTarget(), {
+            error: new DOMException("Commit aborted", "AbortError"),
+            objectStore: () => ({
+              delete: () => queueMicrotask(() => transaction.dispatchEvent(new Event("abort"))),
+              openCursor: () => {
+                queueMicrotask(() => transaction.dispatchEvent(new Event("abort")));
+                return new EventTarget();
+              },
+            }),
+          });
+          return transaction;
+        },
+        close: vi.fn(),
+      }) as unknown as IDBDatabase;
+      const openRequest = Object.assign(new EventTarget(), { result: database, error: null });
+      vi.stubGlobal("indexedDB", {
+        open: () => {
+          queueMicrotask(() => openRequest.dispatchEvent(new Event("success")));
+          return openRequest;
+        },
+      });
+
+      const [threadError, refsError] = yield* Effect.gen(function* () {
+        const cache = yield* Persistence.EnvironmentCacheStore;
+        return [
+          yield* Effect.flip(
+            cache.removeThread(EnvironmentId.make("env"), ThreadId.make("thread")),
+          ),
+          yield* Effect.flip(cache.clearVcsRefs(EnvironmentId.make("env"))),
+        ] as const;
+      }).pipe(Effect.provide(connectionStorageLayer));
+
+      expect(threadError.message).toContain("Commit aborted");
+      expect(refsError.message).toContain("Commit aborted");
+      expect(database.close).toHaveBeenCalledOnce();
+    }),
+  );
+});
+
+describe("IndexedDB connection recovery", () => {
+  it.effect("reports an initial open failure from the cache operation", () =>
+    Effect.gen(function* () {
+      vi.stubGlobal("window", {});
+      const open = vi.fn(() => {
+        throw new DOMException("Storage is unavailable", "InvalidStateError");
+      });
+      vi.stubGlobal("indexedDB", { open });
+
+      yield* Effect.gen(function* () {
+        const cache = yield* Persistence.EnvironmentCacheStore;
+        expect(open).not.toHaveBeenCalled();
+        const error = yield* Effect.flip(
+          cache.loadThread(EnvironmentId.make("env"), ThreadId.make("thread")),
+        );
+        expect(error.message).toContain("Storage is unavailable");
+      }).pipe(Effect.provide(connectionStorageLayer));
+
+      expect(open).toHaveBeenCalledOnce();
+    }),
+  );
+
+  it.effect("reopens after a forced close and finalizes the current connection", () =>
+    Effect.gen(function* () {
+      vi.stubGlobal("window", {});
+      const makeDatabase = () =>
+        Object.assign(new EventTarget(), {
+          close: vi.fn(),
+          transaction: () => ({
+            objectStore: () => ({
+              get: () => {
+                const request = Object.assign(new EventTarget(), {
+                  result: undefined,
+                  error: null,
+                });
+                queueMicrotask(() => request.dispatchEvent(new Event("success")));
+                return request;
+              },
+            }),
+          }),
+        }) as unknown as IDBDatabase;
+      const first = makeDatabase();
+      const second = makeDatabase();
+      const databases = [first, second];
+      let openCount = 0;
+      const open = vi.fn(() => {
+        const request = Object.assign(new EventTarget(), {
+          result: databases[openCount++],
+          error: null,
+        });
+        queueMicrotask(() => request.dispatchEvent(new Event("success")));
+        return request;
+      });
+      vi.stubGlobal("indexedDB", { open });
+
+      yield* Effect.gen(function* () {
+        const cache = yield* Persistence.EnvironmentCacheStore;
+        const environmentId = EnvironmentId.make("env");
+        const threadId = ThreadId.make("thread");
+        expect(Option.isNone(yield* cache.loadThread(environmentId, threadId))).toBe(true);
+        expect(open).toHaveBeenCalledTimes(1);
+
+        first.dispatchEvent(new Event("close"));
+        const recovered = yield* Effect.all(
+          [cache.loadThread(environmentId, threadId), cache.loadThread(environmentId, threadId)],
+          { concurrency: 2 },
+        );
+        expect(recovered.every(Option.isNone)).toBe(true);
+        expect(open).toHaveBeenCalledTimes(2);
+      }).pipe(Effect.provide(connectionStorageLayer));
+
+      expect(first.close).not.toHaveBeenCalled();
+      expect(second.close).toHaveBeenCalledOnce();
+    }),
+  );
+});
+
+describe("IndexedDB connection closed without a close event", () => {
+  it.effect("reopens and retries the failing operation once", () =>
+    Effect.gen(function* () {
+      vi.stubGlobal("window", {});
+      const closing = Object.assign(new EventTarget(), {
+        close: vi.fn(),
+        transaction: () => {
+          // Chromium force-closed this connection; this tab never saw "close".
+          throw new DOMException("The database connection is closing.", "InvalidStateError");
+        },
+      }) as unknown as IDBDatabase;
+      const fresh = Object.assign(new EventTarget(), {
+        close: vi.fn(),
+        transaction: () => ({
+          objectStore: () => ({
+            get: () => {
+              const request = Object.assign(new EventTarget(), { result: undefined, error: null });
+              queueMicrotask(() => request.dispatchEvent(new Event("success")));
+              return request;
+            },
+          }),
+        }),
+      }) as unknown as IDBDatabase;
+      const databases = [closing, fresh];
+      let openCount = 0;
+      const open = vi.fn(() => {
+        const request = Object.assign(new EventTarget(), {
+          result: databases[openCount++],
+          error: null,
+        });
+        queueMicrotask(() => request.dispatchEvent(new Event("success")));
+        return request;
+      });
+      vi.stubGlobal("indexedDB", { open });
+
+      yield* Effect.gen(function* () {
+        const cache = yield* Persistence.EnvironmentCacheStore;
+        const loaded = yield* cache.loadThread(EnvironmentId.make("env"), ThreadId.make("thread"));
+        expect(Option.isNone(loaded)).toBe(true);
+        expect(open).toHaveBeenCalledTimes(2);
+      }).pipe(Effect.provide(connectionStorageLayer));
+    }),
+  );
+});
+
 describe("browser GitHub routing permissions", () => {
   it.effect("revokes across runtimes before storage events and resists stale catalog writes", () =>
     Effect.gen(function* () {