@bizjournals/js-storage 0.0.1 → 0.1.0

package/.gitlab-ci.yml

@@ -0,0 +1,15 @@
+npmrunner:
+  tags:
+    - php73
+  script:
+    - date
+    - node --version
+    - npm --version
+    - rm -f .npmrc
+    - mv build/.npmrc .npmrc
+    - npm install --loglevel=error
+    - npm test
+    - rm -rf node_modules
+    - rm -f .npmrc
+  except:
+    - tags

package/README.md

@@ -0,0 +1,96 @@
+# Storage
+This bundle has helper classes to interact with browser storage options. At present we
+support `localstorage` and `sessionstorage`. These share a common abstract parent.
+
+Storage references are critical to the implementation of our architecture. A reference
+is a named key that contains your data in the selected storage type.
+
+## Installing
+
+Using npm:
+
+```bash
+npm install @bizjournals/vue-core
+```
+
+Using yarn:
+
+```bash
+yarn add @bizjournals/vue-core
+```
+
+**Configuring your environment:**
+
+You will need to configure an `NPM_TOKEN` within your project to include these
+private modules. The best idea is to use an existing project as an example.
+
+_For simple setups the .gitlab-ci.yml file within this project as a guide to accessing
+project variables via the .npmrc file_
+
+## Example
+
+```js
+import { StorageReference, LocalStorage, SessionStorage } from "@bizjournals/js-storage";
+
+// This will setup a reference that is namespaced to bizj
+// The full key in localstorage will be bizj.mykey
+// This key will have an expiration partner that by default will be one hour
+const something = new StorageReference('mykey', new LocalStorage());
+
+something.saveAs({
+    my: 'data'
+});
+
+// local storage has a configurable API as well, and this can be used in storage
+// reference objects too.
+const local = new LocalStorage({
+    // by changing the namespace what was bizj by default will now be notbizj
+    // Example: notbizj.mykey
+    namespace: 'notbizj',
+    expires: 3600 // one hour
+});
+
+
+// session storage uses the same api as local storage
+const somethingElse = new StorageReference('difkey', new SessionStorage({
+    namespace: 'woa'
+}));
+
+const somethingElsesData = somethingElse.obtain();
+```
+
+## Storage Reference
+A storage reference is a keyed object that exists within either local or session storage.
+It may be prefixed with a namespace since of the respective storage container.
+
+### API
+
+**constructor**(cacheKey : String, storageSystem : StorageAbstract)  
+**obtain**()  
+**bust**()  
+**saveAs**(data : Mixed)
+
+## Storage Abstract
+The parent class for both local and session storage creates the API used by each of them.
+
+### API
+
+**constructor**(options : Object : { namespace: String, expires: Number })  
+**getItem**(key: String)  
+**hasItem**(key : String)  
+**setItem**(key : String, value : Mixed, expires = true : Boolean)
+
+
+### Reference
+
+#### getItem
+Gets an item with a specified key. The namespace set in the construction of the object will
+be pre-fixed to the beginning of the string, by default this is `bizj`.
+
+#### hasItem
+This checks to see if the item is available. If it is it'll cache it, so that if you need to
+get the item later you don't need to worry about additional reads.
+
+#### setItem
+Sets the item in storage and updates the item in cache. It will automatically prefix itself
+with the namespace, by default `bizj`.

package/jest.config.cjs

@@ -0,0 +1,3 @@
+module.exports = {
+    transformIgnorePatterns: ["/node_modules/(?!(@bizjournals))/"]
+};

package/lib/abstract/__tests__/storage.clear.spec.js

@@ -14,11 +14,6 @@ describe('core:class >> storageabstract:clear', () => {
         }).not.toThrow();
     });
 
-    it('always returns `this`', () => {
-        const test = storageAbstract.clear();
-        expect(test).toEqual(storageAbstract);
-    });
-
     it('runs the clear method on the storage system when defined', () => {
         storageAbstract.storage = {
             clear: jest.fn()

package/lib/abstract/__tests__/storage.constructor.spec.js

@@ -1,6 +1,5 @@
 import StorageAbstract from '../';
 import { DEFAULT_EXPIRATION, DEFAULT_NAMESPACE } from '../constants';
-import { NAMESPACE_MUST_BE_STRING, EXPIRATION_MUST_BE_POSITIVE_INTEGER } from '../exceptions';
 
 describe('core:class >> storageabstract:constructor', () => {
     it('defaults to constant as it\'s namespace when none provided', () => {
@@ -25,7 +24,7 @@ describe('core:class >> storageabstract:constructor', () => {
         for (const namespace of namespaces) {
             expect(() => {
                 new StorageAbstract({ namespace });
-            }).toThrow(NAMESPACE_MUST_BE_STRING);
+            }).toThrow();
         }
     });
 
@@ -40,11 +39,6 @@ describe('core:class >> storageabstract:constructor', () => {
         expect(storageAbstract.expires).toEqual(expires);
     });
 
-    it('defaults the number of attempts to zero', () => {
-        const storageAbstract = new StorageAbstract();
-        expect(storageAbstract.attempts).toEqual(0);
-    });
-
     it('sets the storage to a default of null', () => {
         const storageAbstract = new StorageAbstract();
         expect(storageAbstract.storage).toEqual({});

package/lib/abstract/__tests__/storage.getitem.spec.js

@@ -19,19 +19,20 @@ describe('core:class >> storageabstract:getitem', () => {
         };
 
         storageClassMock.storage = mockStorage;
+        StorageAbstract.supported = undefined;
     });
 
-    it('returns null when it is not supported', () => {
+    it('returns undefined when it is not supported', () => {
         storageClassMock.isSupported = jest.fn().mockImplementation(() => false);
 
-        expect(storageClassMock.getItem()).toEqual(null);
+        expect(storageClassMock.getItem()).toEqual(undefined);
         expect(storageClassMock.namespaceKey).not.toHaveBeenCalled();
     });
 
-    it('returns null when the item is expired', () => {
+    it('returns undefined when the item is expired', () => {
         storageClassMock.isItemExpired = jest.fn().mockImplementation(() => true);
 
-        expect(storageClassMock.getItem()).toEqual(null);
+        expect(storageClassMock.getItem()).toEqual(undefined);
         expect(storageClassMock.namespaceKey).not.toHaveBeenCalled();
     });
 
@@ -64,8 +65,16 @@ describe('core:class >> storageabstract:getitem', () => {
         expect(storageClassMock.parser).toHaveBeenCalledWith(data);
     });
 
-    it('caches the response data once obtained', () => {
-        storageClassMock.getItem(key);
-        expect(storageClassMock.cache).toHaveBeenCalledTimes(1);
+    it('does not call the `parser` method with the data fetched from suspend or getItem', () => {
+        const data = { hey: 'you' };
+
+        const localStorage = {
+            getItem: jest.fn().mockImplementation(() => data)
+        };
+
+        storageClassMock.storage = localStorage;
+
+        storageClassMock.getItem(key, false);
+        expect(storageClassMock.parser).not.toHaveBeenCalled();
     });
 });

package/lib/abstract/__tests__/storage.hasitem.spec.js

@@ -16,4 +16,10 @@ describe('core:class >> storageabstract:hasitem', () => {
 
         expect(storageClassMock.getItem).toHaveBeenCalledTimes(1);
     });
+
+    it('returns false when the obtained item is undefined', () => {
+        storageClassMock.getItem = jest.fn().mockImplementation(() => undefined);
+
+        expect(storageClassMock.hasItem(key)).toBeFalsy();
+    });
 });

package/lib/abstract/__tests__/storage.issupported.spec.js

@@ -9,10 +9,8 @@ describe('core:class >> storageabstract:issupported', () => {
         mockStorage.setItem.mockClear();
         mockStorage.removeItem.mockClear();
 
-        if (mockStorage._supported) {
-            delete mockStorage._supported;
-        }
         storageAbstract.storage = mockStorage;
+        StorageAbstract.supported = undefined;
     });
 
     it('returns false when the storage system is defaulted', () => {

package/lib/abstract/__tests__/storage.parser.spec.js

@@ -27,10 +27,14 @@ describe('core:class >> storageabstract:parser', () => {
         expect(JSON.parse).toHaveBeenCalledTimes(1);
     });
 
-    it('throws an exception when string is not valid json', () => {
+    it('returns the provided string if it could not be JSON parsed', () => {
         JSON.parse = copyParse;
+        let response;
+
         expect(() => {
-            storageAbstract.parser('wowowow');
-        }).toThrow();
+            response = storageAbstract.parser('wowowow');
+        }).not.toThrow();
+
+        expect(response).toEqual('wowowow');
     });
 });

package/lib/abstract/__tests__/storage.removeitem.spec.js

@@ -19,28 +19,22 @@ describe('core:class >> storageabstract:removeitem', () => {
             removeItem: jest.fn()
         };
 
-        storageClassMock.attempts = 0;
         storageClassMock.storage = mockStorage;
+        StorageAbstract.supported = undefined;
     });
 
-    it('resets the attempts and halts when it is not supported', () => {
+    it('halts when it is not supported', () => {
         storageClassMock.isSupported = jest.fn().mockImplementation(() => false);
-        storageClassMock.removeItem(key);
-
-        expect(storageClassMock.resetAttempts).toHaveBeenCalledTimes(1);
-        expect(storageClassMock.storage.removeItem).not.toHaveBeenCalled();
-    });
 
-    it('resets the attempts and halts when attempts are >= 2', () => {
-        storageClassMock.attempts = 2;
         storageClassMock.removeItem(key);
 
-        expect(storageClassMock.resetAttempts).toHaveBeenCalledTimes(1);
+        expect(storageClassMock.isSupported).toHaveBeenCalledTimes(1);
         expect(storageClassMock.storage.removeItem).not.toHaveBeenCalled();
-
     });
 
-    it('attempts two times when encountering an error', () => {
+    it('falls through when encountering an exception', () => {
+        StorageAbstract.supported = true;
+
         const badStorage = {
             removeItem: jest.fn().mockImplementation(() => {
                 throw new Error('testing code');
@@ -48,23 +42,20 @@ describe('core:class >> storageabstract:removeitem', () => {
         };
 
         storageClassMock.storage = badStorage;
-        storageClassMock.removeItem();
 
-        expect(storageClassMock.storage.removeItem).toHaveBeenCalledTimes(2);
+        expect(() => {
+            storageClassMock.removeItem();
+        }).not.toThrow();
+
+        expect(storageClassMock.storage.removeItem).toHaveBeenCalledTimes(1);
     });
 
     it('removes both the item at namespace and expiration keys', () => {
+        StorageAbstract.supported = true;
         storageClassMock.removeItem();
 
         expect(storageClassMock.namespaceKey).toHaveBeenCalledTimes(1);
         expect(storageClassMock.expirationKey).toHaveBeenCalledTimes(1);
         expect(storageClassMock.storage.removeItem).toHaveBeenCalledTimes(2);
     });
-
-    it('resets attempts to zero on successful return', () => {
-        storageClassMock.removeItem();
-
-        expect(storageClassMock.storage.removeItem).toHaveBeenCalledTimes(2);
-        expect(storageClassMock.resetAttempts).toHaveBeenCalledTimes(1);
-    });
 });

package/lib/abstract/__tests__/storage.setitem.spec.js

@@ -26,22 +26,16 @@ describe('core:class >> storageabstract:setitem', () => {
 
         storageClassMock.attempts = 0;
         storageClassMock.storage = mockStorage;
+        StorageAbstract.supported = undefined;
     });
 
     it('resets the attempts and returns when it is not supported without continuing', () => {
         storageClassMock.isSupported = jest.fn().mockImplementation(() => false);
         storageClassMock.setItem();
 
-        expect(storageClassMock.resetAttempts).toHaveBeenCalledTimes(1);
-        expect(storageClassMock.namespaceKey).not.toHaveBeenCalled();
-    });
-
-    it('resets the attempts and returns when attempts is >= 2 without continuing', () => {
-        storageClassMock.attempts = 3;
-        storageClassMock.setItem();
-
-        expect(storageClassMock.resetAttempts).toHaveBeenCalledTimes(1);
+        expect(storageClassMock.isSupported).toHaveBeenCalledTimes(1);
         expect(storageClassMock.namespaceKey).not.toHaveBeenCalled();
+        expect(mockStorage.setItem).not.toHaveBeenCalled();
     });
 
     it('uses a dynamically generated namespaceKey to set the item', () => {
@@ -59,7 +53,7 @@ describe('core:class >> storageabstract:setitem', () => {
         expect(storageClassMock.storage.setItem).not.toHaveBeenCalled();
     });
 
-    it('calls to set the item one time when not expired', () => {
+    it('calls to set the item one time when not expiring', () => {
         const data = { it: true };
 
         storageClassMock.setItem(key, data, false);
@@ -77,25 +71,4 @@ describe('core:class >> storageabstract:setitem', () => {
         expect(storageClassMock.storage.setItem).toHaveBeenCalledTimes(2);
         expect(storageClassMock.expirationKey).toHaveBeenCalledTimes(1);
     });
-
-    it('calls to cache the data with the key', () => {
-        const data = { it: true };
-
-        storageClassMock.setItem(key, data);
-        expect(storageClassMock.cache).toHaveBeenCalledTimes(1);
-    });
-
-    it('calls clear when there is an error and attempts up to 2 times', () => {
-        storageClassMock.translator = jest.fn().mockImplementation(() => {
-            throw new Error('testing script error');
-        });
-
-        storageClassMock.setItem(key, { data: true });
-        expect(storageClassMock.translator).toHaveBeenCalledTimes(2);
-    });
-
-    it('calls to reset attempts to zero once completed', () => {
-        storageClassMock.setItem(key, { data: true });
-        expect(storageClassMock.resetAttempts).toHaveBeenCalledTimes(1);
-    });
 });

package/lib/abstract/__tests__/storage.translator.spec.js

@@ -1,6 +1,5 @@
 import StorageAbstract from '../';
 
-// Mocking JSON.parse failed in this version of Jest
 describe('core:class >> storageabstract:translator', () => {
     let storageAbstract;
 

package/lib/abstract/index.js

@@ -1,12 +1,6 @@
-import { empty } from "@bizjournals/js-utilities";
 import { DEFAULT_EXPIRATION, DEFAULT_NAMESPACE, EXPIRES_KEY_SUFFIX } from "./constants";
 import { KEY_IS_REQUIRED_TO_FETCH_DATA } from "./exceptions";
 
-// module scoped caching object
-// does share data between session / local / any other
-// If this becomes necessary attach it to the storage object
-const cache = {};
-
 /*
 |--------------------------------------------------------------------------
 | Storage Abstract / Contract
@@ -18,6 +12,13 @@ const cache = {};
 |
 */
 export default class StorageAbstract {
+    /**
+     * Extensions to this abstraction share an enabled state.
+     *
+     * @type {boolean}
+     */
+    static supported;
+
     /**
      * Constructor takes in options for namespace and expiration.
      * Session storage is the default storage type.
@@ -25,41 +26,36 @@ export default class StorageAbstract {
      * @param {object} options
      * @constructor
      */
-    constructor(options = {}) {
+    constructor (options = {}) {
         this.namespace = options.namespace || DEFAULT_NAMESPACE;
         this.expires = options.expires || DEFAULT_EXPIRATION;
-        this.attempts = 0;
 
         this.namespace = this.namespace.toLowerCase();
 
-        cache[this.namespace] = cache[this.namespace] || {};
-
         this.storage = {};
     }
 
     /**
-     * Gets an item from storage.
+     * Gets an item from storage and runs the parser unless explicitly
+     * disabled in the method request.
      *
-     * @param {string} key
-     * @returns {(Array|Number|Object|String)}
+     * @param {String} key
+     * @param {Boolean} parse
+     * @returns {(Array|Number|Object|String|Null)}
      */
-    getItem(key) {
-        if (!this.isSupported() || this.isItemExpired(key)) {
-            return null;
-        }
-
-        let response = null;
+    getItem (key, parse = true) {
+        let response;
 
-        if (cache[this.namespace][key]) {
-            return cache[this.namespace][key];
+        if (!this.isSupported() || this.isItemExpired(key)) {
+            return response;
         }
 
         try {
-            const generatedKey = this.namespaceKey(key);
+            response = this.storage.getItem(this.namespaceKey(key));
 
-            response = this.parser(cache[generatedKey] || this.storage.getItem(generatedKey));
+            if (response === null) return undefined;
 
-            this.cache(key, response);
+            response = parse ? this.parser(response) : response;
         } catch (e) {
             // fall through
         }
@@ -71,10 +67,18 @@ export default class StorageAbstract {
      * Parses the data returned from the storage system
      *
      * @param data
-     * @returns {any}
+     * @returns {*}
      */
-    parser(data) {
-        return typeof data === "string" ? JSON.parse(data) : data;
+    parser (data) {
+        try {
+            if (typeof data === "string") {
+                data = JSON.parse(data);
+            }
+        } catch (e) {
+            // fall through
+        }
+
+        return data;
     }
 
     /**
@@ -83,8 +87,8 @@ export default class StorageAbstract {
      * @param value
      * @returns {any}
      */
-    translator(value) {
-        return typeof value === "string" ? value : JSON.stringify(value);
+    translator (value) {
+        return typeof value === 'string' ? value : JSON.stringify(value);
     }
 
     /**
@@ -94,9 +98,9 @@ export default class StorageAbstract {
      * @param {(array|object|number|string)} value
      * @param {boolean} expires
      */
-    setItem(key, value, expires = true) {
-        if (!this.isSupported() || this.attempts >= 2) {
-            return this.resetAttempts();
+    setItem (key, value, expires = true) {
+        if (!this.isSupported()) {
+            return;
         }
 
         const generatedKey = this.namespaceKey(key);
@@ -105,16 +109,14 @@ export default class StorageAbstract {
             this.storage.setItem(generatedKey, this.translator(value));
 
             if (expires) {
-                this.storage.setItem(this.expirationKey(key), String(this.timestamp(this.expires)));
+                this.storage.setItem(
+                  this.expirationKey(key),
+                  String(this.timestamp(this.expires))
+                );
             }
-
-            this.cache(key, value);
         } catch (e) {
-            this.attempts++;
-            this.setItem(key, value, expires);
+            // fall through
         }
-
-        return this.resetAttempts();
     }
 
     /**
@@ -122,48 +124,28 @@ export default class StorageAbstract {
      *
      * @param {string} key
      */
-    removeItem(key) {
-        if (!this.isSupported() || this.attempts >= 2) {
-            return this.resetAttempts();
+    removeItem (key) {
+        if (!this.isSupported()) {
+            return;
         }
 
         try {
             this.storage.removeItem(this.namespaceKey(key));
             this.storage.removeItem(this.expirationKey(key));
-
-            this.free(key);
         } catch (e) {
-            this.attempts++;
-            this.removeItem(key);
+            // fall through
         }
-
-        return this.resetAttempts();
-    }
-
-    /**
-     * Resets the number of attempt operations to zero.
-     *
-     * @returns {StorageAbstract}
-     */
-    resetAttempts() {
-        this.attempts = 0;
-
-        return this;
     }
 
     /**
      * Clears all items from storage.
      */
-    clear() {
+    clear () {
         try {
             this.storage.clear();
-
-            cache[this.namespace] = {};
         } catch (e) {
             // fall through
         }
-
-        return this;
     }
 
     /**
@@ -172,8 +154,8 @@ export default class StorageAbstract {
      * @param {string} key
      * @returns {boolean}
      */
-    hasItem(key) {
-        return !empty(this.getItem(key));
+    hasItem (key) {
+        return this.getItem(key, false) !== undefined;
     }
 
     /**
@@ -182,7 +164,7 @@ export default class StorageAbstract {
      * @param {number} offset
      * @returns {number}
      */
-    timestamp(offset = 0) {
+    timestamp (offset = 0) {
         return Math.ceil(Date.now() / 1000) + offset;
     }
 
@@ -192,16 +174,16 @@ export default class StorageAbstract {
      * @param {string} key
      * @returns {string}
      */
-    namespaceKey(key) {
+    namespaceKey (key) {
         if (typeof key !== "string") {
             throw new Error(KEY_IS_REQUIRED_TO_FETCH_DATA);
         }
 
-        if (key.indexOf(`${this.namespace}.`) === 0) {
+        if (key.indexOf(`${ this.namespace }.`) === 0) {
             key = key.slice(this.namespace.length + 1);
         }
 
-        return `${this.namespace}.${key.toLowerCase()}`;
+        return `${ this.namespace }.${ key.toLowerCase() }`;
     }
 
     /**
@@ -209,8 +191,8 @@ export default class StorageAbstract {
      *
      * @returns {string}
      */
-    expirationKey(key) {
-        return `${this.namespaceKey(key)}.${EXPIRES_KEY_SUFFIX}`;
+    expirationKey (key) {
+        return `${ this.namespaceKey(key) }.${ EXPIRES_KEY_SUFFIX }`;
     }
 
     /**
@@ -219,7 +201,7 @@ export default class StorageAbstract {
      * @param {string} key
      * @returns {boolean}
      */
-    isItemExpired(key) {
+    isItemExpired (key) {
         if (!this.isSupported()) {
             return false;
         }
@@ -242,52 +224,38 @@ export default class StorageAbstract {
         return false;
     }
 
-    /**
-     * Stores the data in memory.
-     *
-     * @param key
-     * @param value
-     */
-    cache(key, value) {
-        cache[this.namespace][key] = value;
-
-        return this;
-    }
-
-    /**
-     * Frees the data from memory.
-     *
-     * @param key
-     * @param value
-     */
-    free(key) {
-        if (cache[this.namespace][key]) {
-            delete cache[this.namespace][key];
-        }
-
-        return this;
-    }
-
     /**
      * Checks to see if the storage system is supported
      *
      * @returns {boolean}
      */
-    isSupported() {
-        if (typeof this.storage._supported === "boolean") {
-            return this.storage._supported;
+    isSupported () {
+        if (typeof StorageAbstract.supported === "boolean") {
+            return StorageAbstract.supported;
         }
 
-        const test = `${this.namespaceKey("storage")}.test`;
+        const test = 'biz.storage.test';
 
         try {
-            this.storage.setItem(test, test);
+            this.storage.setItem(test, '1');
             this.storage.removeItem(test);
-            this.storage._supported = true;
+
+            StorageAbstract.supported = true;
         } catch (e) {
-            this.storage._supported = false;
+            StorageAbstract.supported = e instanceof DOMException &&
+              (
+                // everything except Firefox
+                e.code === 22 ||
+                // Firefox
+                e.code === 1014 ||
+                // test name field too, because code might not be present
+                // everything except Firefox
+                e.name === 'QuotaExceededError' ||
+                // Firefox
+                e.name === 'NS_ERROR_DOM_QUOTA_REACHED'
+              ) && (this.storage && this.storage.length !== 0);
         }
 
-        return this.storage._supported;
+        return StorageAbstract.supported;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@bizjournals/js-storage",
-    "version": "0.0.1",
+    "version": "0.1.0",
     "description": "ACBJ javascript storage classes",
     "repository": {
         "git": "https://gitlab.bizjournals.com/bizjournals/js-storage"
@@ -9,17 +9,17 @@
     "type": "module",
     "sideEffects": false,
     "scripts": {
-        "test": "jest --transformIgnorePatterns \"node_modules/(?!(@bizjournals))/\""
+        "test": "jest",
+        "preversion": "npm test",
+        "postversion": "git push && git push --tags && npm publish"
     },
     "keywords": [],
     "author": "DPD",
     "license": "UNLICENSED",
     "devDependencies": {
-        "@babel/preset-env": "^7.9.5",
+        "@babel/preset-env": "^7.10.3",
         "babel-jest": "^25.4.0",
         "jest": "^25.4.0"
     },
-    "dependencies": {
-        "@bizjournals/js-utilities": "0.0.1"
-    }
+    "dependencies": {}
 }

package/lib/abstract/__tests__/storage.resetattempts.spec.js

@@ -1,20 +0,0 @@
-import StorageAbstract from '../';
-
-describe('core:class >> storageabstract:resetattempts', () => {
-    let storageAbstract;
-
-    beforeAll(() => {
-        storageAbstract = new StorageAbstract();
-    });
-
-    it('resets the attempts to 0 when called', () => {
-        storageAbstract.attempts = 2;
-
-        storageAbstract.resetAttempts();
-        expect(storageAbstract.attempts).toEqual(0);
-    });
-
-    it('returns `this`', () => {
-        expect(storageAbstract.resetAttempts()).toEqual(storageAbstract);
-    });
-});