Merge pull request #40 from microsoft/bviswanathan/memorystore-fix

InMemoryStore will create commitedStoreData only when provider supportsRollback

Author: M1Les

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@microsoft/objectstoreprovider",
-  "version": "0.6.38",
+  "version": "0.6.39",
   "description": "A cross-browser object store library",
   "author": "Mukundan Kavanur Kidambi <[email protected]>",
   "scripts": {

src/InMemoryProvider.ts

@@ -67,10 +67,12 @@ export class InMemoryProvider extends DbProvider {
 
   private _lockHelper: TransactionLockHelper | undefined;
   private readonly _mapType?: OrderedMapType;
+  private readonly _supportsRollback?: boolean;
 
-  constructor(mapType?: OrderedMapType) {
+  constructor(mapType?: OrderedMapType, supportsRollback = false) {
     super();
     this._mapType = mapType;
+    this._supportsRollback = supportsRollback;
   }
 
   open(
@@ -105,7 +107,13 @@ export class InMemoryProvider extends DbProvider {
   ): Promise<DbTransaction> {
     return this._lockHelper!!!.openTransaction(storeNames, writeNeeded).then(
       (token: any) =>
-        new InMemoryTransaction(this, this._lockHelper!!!, token, writeNeeded)
+        new InMemoryTransaction(
+          this,
+          this._lockHelper!!!,
+          token,
+          writeNeeded,
+          this._supportsRollback!
+        )
     );
   }
 
@@ -128,19 +136,20 @@ class InMemoryTransaction implements DbTransaction {
     private _prov: InMemoryProvider,
     private _lockHelper: TransactionLockHelper,
     private _transToken: TransactionToken,
-    writeNeeded: boolean
+    private _writeNeeded: boolean,
+    private _supportsRollback: boolean
   ) {
     // Close the transaction on the next tick.  By definition, anything is completed synchronously here, so after an event tick
     // goes by, there can't have been anything pending.
-    if (writeNeeded) {
+    if (this._writeNeeded) {
       this._openTimer = setTimeout(() => {
         this._openTimer = undefined;
         this._commitTransaction();
         this._lockHelper.transactionComplete(this._transToken);
       }, 0) as any as number;
     } else {
+      // read-only
       this._openTimer = undefined;
-      this._commitTransaction();
       this._lockHelper.transactionComplete(this._transToken);
     }
   }
@@ -156,6 +165,11 @@ class InMemoryTransaction implements DbTransaction {
   }
 
   abort(): void {
+    if (!this._supportsRollback) {
+      throw new Error(
+        "Unable to abort transaction since provider doesn't support rollback"
+      );
+    }
     this._stores.forEach((store) => {
       store.internal_rollbackPendingData();
     });
@@ -188,7 +202,11 @@ class InMemoryTransaction implements DbTransaction {
     if (!store) {
       throw new Error("Store not found: " + storeName);
     }
-    const ims = new InMemoryStore(this, store);
+    const ims = new InMemoryStore(
+      this,
+      store,
+      this._writeNeeded && this._supportsRollback
+    );
     this._stores.set(storeName, ims);
     return ims;
   }
@@ -199,27 +217,40 @@ class InMemoryTransaction implements DbTransaction {
 }
 
 class InMemoryStore implements DbStore {
-  private _committedStoreData: Map<string, ItemType>;
+  private _committedStoreData?: Map<string, ItemType>;
   private _mergedData: Map<string, ItemType>;
   private _storeSchema: StoreSchema;
   private _indices: Map<string, InMemoryIndex>;
   private _mapType?: OrderedMapType;
-  constructor(private _trans: InMemoryTransaction, storeInfo: StoreData) {
+  constructor(
+    private _trans: InMemoryTransaction,
+    storeInfo: StoreData,
+    private _supportsRollback: boolean
+  ) {
     this._storeSchema = storeInfo.schema;
-    this._committedStoreData = new Map(storeInfo.data);
+    if (this._supportsRollback) {
+      this._committedStoreData = new Map(storeInfo.data);
+    }
     this._indices = storeInfo.indices;
     this._mergedData = storeInfo.data;
     this._mapType = storeInfo.mapType;
   }
 
   internal_commitPendingData(): void {
-    this._committedStoreData = new Map(this._mergedData);
+    if (this._supportsRollback) {
+      this._committedStoreData = new Map(this._mergedData);
+    }
     // Indices were already updated, theres no need to update them now.
   }
 
   internal_rollbackPendingData(): void {
+    if (!this._supportsRollback) {
+      throw new Error(
+        "Unable to rollback since InMemoryStore was created with supportsRollback = false"
+      );
+    }
     this._mergedData.clear();
-    this._committedStoreData.forEach((val, key) => {
+    this._committedStoreData?.forEach((val, key) => {
       this._mergedData.set(key, val);
     });
     // Recreate all indexes on a roll back.

src/tests/ObjectStoreProvider.spec.ts

@@ -25,13 +25,14 @@ function openProvider(
   providerName: string,
   schema: DbSchema,
   wipeFirst: boolean,
-  handleOnClose?: OnCloseHandler
+  handleOnClose?: OnCloseHandler,
+  supportsRollback?: boolean
 ) {
   let provider: DbProvider;
   if (providerName === "memory-rbtree") {
-    provider = new InMemoryProvider("red-black-tree");
+    provider = new InMemoryProvider("red-black-tree", supportsRollback);
   } else if (providerName === "memory-btree") {
-    provider = new InMemoryProvider("b+tree");
+    provider = new InMemoryProvider("b+tree", supportsRollback);
   } else if (providerName === "indexeddb") {
     provider = new IndexedDbProvider();
   } else if (providerName === "indexeddbfakekeys") {
@@ -2599,6 +2600,8 @@ describe("ObjectStoreProvider", function () {
                   },
                 ],
               },
+              true,
+              undefined,
               true
             )
               .then((prov) => {
@@ -4955,6 +4958,81 @@ describe("ObjectStoreProvider", function () {
           });
         });
       });
+
+      if (provName === "memory-rbtree" || provName === "memory-btree") {
+        it("Doesn't create committedStoreData for read-only operation", async () => {
+          return openProvider(
+            provName,
+            {
+              version: 2,
+              stores: [
+                {
+                  name: "test",
+                  primaryKeyPath: "id",
+                  indexes: [
+                    {
+                      name: "i",
+                      keyPath: "txt",
+                      fullText: true,
+                      unique: false,
+                    },
+                  ],
+                },
+              ],
+            },
+            true
+          ).then((prov) => {
+            const itemsToPut = [];
+            for (var i = 0; i < 10; i++) {
+              itemsToPut.push({ id: `a${i}`, txt: `aaaaaa${i}` });
+            }
+            assert.equal((<InMemoryProvider>prov)["_supportsRollback"], false);
+            prov.put("test", itemsToPut).then(() => {
+              prov.openTransaction(["test"], false).then((transaction) => {
+                const store = <any>transaction.getStore("test"); // InMemoryStore
+                assert.equal(store["_supportsRollback"], false);
+                assert.equal(store["_committedStoreData"], undefined);
+                prov.close();
+              });
+            });
+          });
+        });
+        it("InMemoryProvider with supportsRollback = true", async () => {
+          return openProvider(
+            provName,
+            {
+              version: 2,
+              stores: [
+                {
+                  name: "test",
+                  primaryKeyPath: "id",
+                },
+              ],
+            },
+            true,
+            undefined,
+            true
+          ).then((prov) => {
+            const itemsToPut = [];
+            for (var i = 0; i < 10; i++) {
+              itemsToPut.push({ id: `a${i}`, txt: `aaaaaa${i}` });
+            }
+            assert.equal((<InMemoryProvider>prov)["_supportsRollback"], true);
+            prov.put("test", itemsToPut).then(() => {
+              prov.openTransaction(["test"], true).then((transaction) => {
+                const store = <any>transaction.getStore("test"); // InMemoryStore
+                assert.equal(store["_supportsRollback"], true);
+                assert.equal(
+                  Array.from(store["_committedStoreData"]?.values() || [])
+                    .length,
+                  10
+                );
+                prov.close();
+              });
+            });
+          });
+        });
+      }
     });
   });
 });