Cleaned up state, seems to be working well.

coverage at 100%

Signed-off-by: quobix <[email protected]>

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pb33f/saddlebag",
-  "version": "0.0.0",
+  "version": "0.1.0",
   "license": "MIT",
   "private": false,
   "description": "A tiny, pure JavaScript in-memory object store library for simple application state management",

src/bag.manager.ts

@@ -58,18 +58,14 @@ class saddlebagManager implements BagManager {
     }
 
     loadStatefulBags(): Promise<BagDB> {
-        return new Promise<BagDB>((resolve, reject) => {
+        return new Promise<BagDB>((resolve) => {
             const request = indexedDB.open(BAG_DB_NAME, 1);
             request.onupgradeneeded = () => {
                 // @ts-ignore
                 this._db = request.result
                 this._db.createObjectStore(BAG_OBJECT_STORE);
             };
 
-            request.onerror = (event) => {
-                reject(event);
-            }
-
             request.onsuccess = () => {
                 // @ts-ignore
                 this._db = request.result
@@ -78,10 +74,6 @@ class saddlebagManager implements BagManager {
                     const tx =  this._db.transaction(BAG_OBJECT_STORE)
                     const cursor = tx.objectStore(BAG_OBJECT_STORE).openCursor()
 
-                    cursor.onerror = (event) => {
-                        reject(event);
-                    }
-
                     cursor.onsuccess = (event) => {
                         // @ts-ignore
                         let cursor = event.target.result;
@@ -119,7 +111,7 @@ class saddlebagManager implements BagManager {
         if (this._bags.has(key)) {
             return this._bags.get(key);
         }
-        return CreateBag<T>(key, );
+        return this.createBag(key)
     }
 
     resetBags() {

src/saddlebag.ts

@@ -58,20 +58,23 @@ export interface Bag<T = any> {
      * key is changed, the callback will be called with the new value.
      * @param {string} key to be monitored
      * @param {BagValueSubscriptionFunction<T>} callback to fire on every change, updated value will be passed
+     * @return {Subscription} a handle to the subscription
      */
     subscribe(key: string, callback: BagValueSubscriptionFunction<T>): Subscription;
 
     /**
      * onAllChanges will add a subscription to the bag for all changes. Any time that
      * any value changes in the bag, subscribers will be notified.
      * @param {BagAllChangeSubscriptionFunction<T>} callback to fire on every change
+     * @return {Subscription} a handle to the subscription
      */
     onAllChanges(callback: BagAllChangeSubscriptionFunction<T>): Subscription;
 
     /**
      * onPopulated will add a subscription to the bag for when the bag is populated with
      * any data. The entire contents of the bag will be passed to the callback.
      * @param {BagPopulatedSubscriptionFunction<T>} callback
+     * @return {Subscription} a handle to the subscription
      */
     onPopulated(callback: BagPopulatedSubscriptionFunction<T>): Subscription;
 
@@ -84,11 +87,13 @@ export interface Bag<T = any> {
 
     /**
      * id is the unique identifier of the bag.
+     * @return {string} the unique identifier of the bag
      */
     get id(): string;
 
     /**
      * db is the IndexedID database that the bag is associated with.
+     * @param db {IDBDatabase | undefined} indexedDB used to store the bag.
      */
     set db(db: IDBDatabase | undefined);
 }

src/saddlebag_engine.spec.ts

@@ -44,7 +44,20 @@ describe('store basics', () => {
                         const bag2 = bm2.getBag<string>('foo');
                         if (bag2) {
                             expect(bag2.get('foo')).toEqual('bar');
-                            resolve(result)
+
+
+                            // now reset the bag and check its gone from the db
+                            bag2.reset();
+                            const bm3 = CreateBagManager(true)
+                            expect(bm3).toBeDefined();
+
+                            bm3.loadStatefulBags().then(() => {
+
+                                // should be gone.
+                                expect(bag2.get('foo')).toBeUndefined()
+                                resolve(result)
+
+                            });
                         }
                     })
                 }

src/saddlebag_engine.ts

@@ -70,7 +70,6 @@ class bag<T> {
     private _stateful: boolean;
     private _values: Map<string, T>;
     private _db: IDBDatabase | undefined;
-    private _bagStore: IDBObjectStore | undefined;
 
     _subscriptions: Map<string, BagValueSubscriptionFunction<T>[]>;
     _allChangesSubscriptions: BagAllChangeSubscriptionFunction<T>[];
@@ -110,6 +109,12 @@ class bag<T> {
             this.alertSubscribers(key, undefined); // the value is gone!
         });
         this._values = new Map<string, T>();
+        // if there is a db, wipe out the bag in the db
+        if (this._stateful && this._db) {
+            this._db.transaction([BAG_OBJECT_STORE], 'readwrite')
+                .objectStore(BAG_OBJECT_STORE)
+                .delete(this._id);
+        }
     }
 
     private alertSubscribers(key: string, value: T | undefined): void {