initial commit

Author: michaellaw

src/IndexedDbProvider.ts

@@ -159,7 +159,7 @@ export class IndexedDbProvider extends DbProvider {
         resolve(req.result);
       };
       req.onerror = (ev) => {
-        reject(ev);
+        reject((ev.target as IDBRequest)?.error ?? ev);
       };
     });
   }
@@ -566,32 +566,22 @@ export class IndexedDbProvider extends DbProvider {
             isCopyRequired: false,
             upgradeSteps,
             ...upgradeMetadata,
-            errorName: err?.target?.error?.name || "Unknown",
-            errorMessage: err
-              ? `${err?.message} ${err?.target?.error} ${err?.target?.error?.name}`
-              : "Unknown error occurred during upgrade",
+            errorName: err?.name || "Unknown",
+            errorMessage: err?.message || "Unknown error occurred during upgrade",
           });
         }
 
-        if (
-          err &&
-          err.type === "error" &&
-          err.target &&
-          err.target.error &&
-          err.target.error.name === "VersionError"
-        ) {
+        if (err instanceof DOMException && err.name === "VersionError") {
           if (!wipeIfExists) {
             this.logWriter.log(
-              `Database version too new, Wiping: ${
-                err.target.error.message || err.target.error.name
-              }`
+              `Database version too new, Wiping: ${err.message || err.name}`
             );
 
             return this.open(dbName, schema, true, verbose);
           }
         }
         this.logWriter.error(
-          `Error opening db, message: ${err?.message} ${err?.target?.error} ${err?.target?.error?.name}`,
+          `Error opening db, message: ${err?.message}, name: ${err?.name}`,
           {
             dbName,
           }
@@ -759,10 +749,10 @@ class IndexedDbTransaction implements DbTransaction {
 
         lockHelper.transactionFailed(
           this._transToken,
-          "IndexedDbTransaction OnError: " +
-            (this._trans.error ? this._trans.error.message : undefined) +
-            ", History: " +
-            history.join(",")
+          this._trans.error ??
+            new Error(
+              "IndexedDbTransaction OnError, History: " + history.join(",")
+            )
         );
       };
 
@@ -783,10 +773,10 @@ class IndexedDbTransaction implements DbTransaction {
 
         lockHelper.transactionFailed(
           this._transToken,
-          "IndexedDbTransaction Aborted, Error: " +
-            (this._trans.error ? this._trans.error.message : undefined) +
-            ", History: " +
-            history.join(",")
+          this._trans.error ??
+            new Error(
+              "IndexedDbTransaction Aborted, History: " + history.join(",")
+            )
         );
       };
     }

src/TransactionLockHelper.ts

@@ -170,7 +170,7 @@ export class TransactionLockHelper {
     this._cleanTransaction(token);
   }
 
-  transactionFailed(token: TransactionToken, message: string) {
+  transactionFailed(token: TransactionToken, message: string | Error) {
     const pendingTransIndex = findIndex(
       this._pendingTransactions,
       (trans) => trans.token === token
@@ -183,7 +183,9 @@ export class TransactionLockHelper {
         const toResolve = pendingTrans.completionDefer;
         this._pendingTransactions.splice(pendingTransIndex, 1);
         pendingTrans.completionDefer = undefined;
-        toResolve.reject(new Error(message));
+        toResolve.reject(
+          message instanceof Error ? message : new Error(message)
+        );
       } else {
         throw new Error(
           "Failing a transaction that has already been completed. Stores: " +

src/tests/ObjectStoreProvider.spec.ts

@@ -5430,4 +5430,112 @@ describe("ObjectStoreProvider", function () {
       }
     });
   });
+
+  describe("IndexedDbProvider WrapRequest error surfacing", () => {
+    it("resolves with req.result on success", (done) => {
+      const mockRequest = {} as IDBRequest<string>;
+      (mockRequest as any).result = "test-value";
+
+      IndexedDbProvider.WrapRequest(mockRequest).then(
+        (result) => {
+          try {
+            assert.equal(result, "test-value");
+            done();
+          } catch (e) {
+            done(e);
+          }
+        },
+        () => done(new Error("Expected promise to resolve"))
+      );
+
+      mockRequest.onsuccess!({} as any);
+    });
+
+    it("rejects with the actual IDBRequest.error DOMException when onerror fires", (done) => {
+      const mockError = new DOMException(
+        "Quota exceeded",
+        "QuotaExceededError"
+      );
+      const mockRequest = {} as IDBRequest<any>;
+
+      IndexedDbProvider.WrapRequest(mockRequest).then(
+        () => done(new Error("Expected promise to reject")),
+        (err) => {
+          try {
+            assert.strictEqual(err, mockError);
+            assert.equal(err.name, "QuotaExceededError");
+            done();
+          } catch (e) {
+            done(e);
+          }
+        }
+      );
+
+      mockRequest.onerror!({ target: { error: mockError } } as any);
+    });
+
+    it("falls back to the raw event when IDBRequest.error is null", (done) => {
+      const mockRequest = {} as IDBRequest<any>;
+      const mockEvent = { target: { error: null } } as any;
+
+      IndexedDbProvider.WrapRequest(mockRequest).then(
+        () => done(new Error("Expected promise to reject")),
+        (err) => {
+          try {
+            assert.strictEqual(err, mockEvent);
+            done();
+          } catch (e) {
+            done(e);
+          }
+        }
+      );
+
+      mockRequest.onerror!(mockEvent);
+    });
+  });
+
+  describe("IndexedDbProvider put DOMException propagation", () => {
+    it("put rejects with the DOMException surfaced from WrapRequest", (done) => {
+      const quotaError = new DOMException(
+        "Quota exceeded",
+        "QuotaExceededError"
+      );
+      const originalWrapRequest =
+        IndexedDbProviderModule.IndexedDbProvider.WrapRequest;
+
+      openProvider(
+        "indexeddb",
+        { version: 1, stores: [{ name: "test", primaryKeyPath: "id" }] },
+        true
+      )
+        .then((prov) => {
+          // Mock only after a successful open so the open itself is unaffected
+          IndexedDbProviderModule.IndexedDbProvider.WrapRequest =
+            function (): Promise<any> {
+              return Promise.reject(quotaError);
+            };
+          return prov.put("test", { id: "abc", val: "hello" }).then(
+            () => {
+              prov.close();
+              done(new Error("Expected put to reject"));
+            },
+            (err) => {
+              prov.close();
+              try {
+                assert.strictEqual(err, quotaError);
+                assert.equal(err.name, "QuotaExceededError");
+                done();
+              } catch (e) {
+                done(e);
+              }
+            }
+          );
+        })
+        .catch((err) => done(err))
+        .finally(() => {
+          IndexedDbProviderModule.IndexedDbProvider.WrapRequest =
+            originalWrapRequest;
+        });
+    });
+  });
 });