@bizjournals/js-storage 0.0.1

package/babel.config.js

@@ -0,0 +1,12 @@
+module.exports = {
+    presets: [
+        [
+            "@babel/preset-env",
+            {
+                targets: {
+                    node: "current",
+                },
+            },
+        ],
+    ],
+};

package/lib/abstract/__mocks__/mock-storage.js

@@ -0,0 +1,19 @@
+let store = {};
+
+export default {
+    clear: jest.fn().mockImplementation(() => {
+        store = {};
+    }),
+
+    getItem: jest.fn().mockImplementation((key) => {
+        return store[key];
+    }),
+
+    setItem: jest.fn().mockImplementation((key, value) => {
+        store[key] = value;
+    }),
+
+    removeItem: jest.fn().mockImplementation((key) => {
+        delete store[key];
+    })
+};

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

@@ -0,0 +1,30 @@
+import StorageAbstract from '../';
+
+describe('core:class >> storageabstract:clear', () => {
+    let storageAbstract;
+
+    beforeAll(() => {
+        storageAbstract = new StorageAbstract();
+    });
+
+    it('never fails or throws when storage is not set', () => {
+        delete storageAbstract.storage;
+        expect(() => {
+            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()
+        };
+
+        storageAbstract.clear();
+        expect(storageAbstract.storage.clear).toHaveBeenCalledTimes(1);
+    });
+});

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

@@ -0,0 +1,52 @@
+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', () => {
+        const storageAbstract = new StorageAbstract();
+        expect(storageAbstract.namespace).toMatch(DEFAULT_NAMESPACE);
+    });
+
+    it('accepts an object parameter with key namespace and sets it to this.namespace', () => {
+        const namespace = 'test';
+        const storageAbstract = new StorageAbstract({ namespace });
+        expect(storageAbstract.namespace).toMatch(namespace);
+    });
+
+    it('coercies the namespace to lower case before setting', () => {
+        const namespace = 'TeSt';
+        const storageAbstract = new StorageAbstract({ namespace });
+        expect(storageAbstract.namespace).toMatch(namespace.toLowerCase());
+    });
+
+    it('throws error when namespace provided is not a string', () => {
+        const namespaces = [true, {}, [], 12];
+        for (const namespace of namespaces) {
+            expect(() => {
+                new StorageAbstract({ namespace });
+            }).toThrow(NAMESPACE_MUST_BE_STRING);
+        }
+    });
+
+    it('defaults to constant as it\'s expiration when none provided', () => {
+        const storageAbstract = new StorageAbstract();
+        expect(storageAbstract.expires).toEqual(DEFAULT_EXPIRATION);
+    });
+
+    it('accepts an object parameter with key expires and sets it to this.expires', () => {
+        const expires = 3600 * 4;
+        const storageAbstract = new StorageAbstract({ expires });
+        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.expirationkey.spec.js

@@ -0,0 +1,22 @@
+import StorageAbstract from '../';
+import { EXPIRES_KEY_SUFFIX } from '../constants';
+
+describe('core:class >> storageabstract:namespacekey', () => {
+    let storageAbstract;
+
+    beforeEach(() => {
+        storageAbstract = new StorageAbstract();
+    });
+
+    it('calls the namespaceKey to generate the prefix', () => {
+        storageAbstract.namespaceKey = jest.fn();
+        storageAbstract.expirationKey('hey');
+        expect(storageAbstract.namespaceKey).toHaveBeenCalledTimes(1);
+    });
+
+    it('returns a concatenated variation of the namespace and string key', () => {
+        let key = 'key';
+        expect(storageAbstract.expirationKey(key))
+            .toEqual(`${ storageAbstract.namespaceKey(key) }.${ EXPIRES_KEY_SUFFIX }`);
+    });
+});

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

@@ -0,0 +1,71 @@
+import StorageAbstract from '../';
+
+describe('core:class >> storageabstract:getitem', () => {
+    let storageClassMock, mockStorage, key = 'test';
+
+    beforeAll(() => {
+        storageClassMock = new StorageAbstract();
+    });
+
+    beforeEach(() => {
+        storageClassMock.namespaceKey = jest.fn().mockImplementation(key => key);
+        storageClassMock.parser = jest.fn().mockImplementation(data => data);
+        storageClassMock.cache = jest.fn().mockImplementation(data => data);
+        storageClassMock.isSupported = jest.fn().mockImplementation(() => true);
+        storageClassMock.isItemExpired = jest.fn().mockImplementation(() => false);
+
+        mockStorage = {
+            getItem: jest.fn()
+        };
+
+        storageClassMock.storage = mockStorage;
+    });
+
+    it('returns null when it is not supported', () => {
+        storageClassMock.isSupported = jest.fn().mockImplementation(() => false);
+
+        expect(storageClassMock.getItem()).toEqual(null);
+        expect(storageClassMock.namespaceKey).not.toHaveBeenCalled();
+    });
+
+    it('returns null when the item is expired', () => {
+        storageClassMock.isItemExpired = jest.fn().mockImplementation(() => true);
+
+        expect(storageClassMock.getItem()).toEqual(null);
+        expect(storageClassMock.namespaceKey).not.toHaveBeenCalled();
+    });
+
+    it('calls `namespace` key to get a dynamically generated key', () => {
+        storageClassMock.namespaceKey = jest.fn().mockImplementation(() => {
+            throw new Error('Just a test fall through.');
+        });
+
+        storageClassMock.getItem();
+        expect(storageClassMock.namespaceKey).toHaveBeenCalledTimes(1);
+    });
+
+    it('calls getItem on the storage system when suspended data not available', () => {
+        storageClassMock.getItem(key);
+        expect(storageClassMock.storage.getItem).toHaveBeenCalledTimes(1);
+        expect(storageClassMock.storage.getItem).toHaveBeenCalledWith(key);
+    });
+
+    it('calls 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);
+        expect(storageClassMock.parser).toHaveBeenCalled();
+        expect(storageClassMock.parser).toHaveBeenCalledWith(data);
+    });
+
+    it('caches the response data once obtained', () => {
+        storageClassMock.getItem(key);
+        expect(storageClassMock.cache).toHaveBeenCalledTimes(1);
+    });
+});

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

@@ -0,0 +1,19 @@
+import StorageAbstract from '../';
+
+describe('core:class >> storageabstract:hasitem', () => {
+    let storageClassMock, key = 'test';
+
+    beforeAll(() => {
+        storageClassMock = new StorageAbstract();
+    });
+
+    beforeEach(() => {
+        storageClassMock.getItem = jest.fn().mockImplementation(key => key);
+    });
+
+    it('calls getItem to fetch the item from the storage system', () => {
+        storageClassMock.hasItem(key);
+
+        expect(storageClassMock.getItem).toHaveBeenCalledTimes(1);
+    });
+});

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

@@ -0,0 +1,37 @@
+import StorageAbstract from '../';
+import mockStorage from '../__mocks__/mock-storage';
+
+describe('core:class >> storageabstract:issupported', () => {
+    let storageAbstract;
+
+    beforeEach(() => {
+        storageAbstract = new StorageAbstract();
+        mockStorage.setItem.mockClear();
+        mockStorage.removeItem.mockClear();
+
+        if (mockStorage._supported) {
+            delete mockStorage._supported;
+        }
+        storageAbstract.storage = mockStorage;
+    });
+
+    it('returns false when the storage system is defaulted', () => {
+        storageAbstract.storage = {};
+        expect(storageAbstract.isSupported()).toBeFalsy();
+    });
+
+    it('returns true when the storage system is valid and usable', () => {
+        storageAbstract.storage = mockStorage;
+        expect(storageAbstract.isSupported()).toBeTruthy();
+        expect(mockStorage.setItem).toHaveBeenCalledTimes(1);
+        expect(mockStorage.removeItem).toHaveBeenCalledTimes(1);
+    });
+
+    it('returns a stored answer once the storage system has been checked', () => {
+        storageAbstract.storage = mockStorage;
+        let isSupported = storageAbstract.isSupported();
+        isSupported = storageAbstract.isSupported();
+        expect(mockStorage.setItem).toHaveBeenCalledTimes(1);
+        expect(mockStorage.removeItem).toHaveBeenCalledTimes(1);
+    });
+});

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

@@ -0,0 +1,54 @@
+import StorageAbstract from '../';
+import { KEY_IS_REQUIRED_TO_FETCH_DATA } from '../exceptions';
+
+describe('core:class >> storageabstract:namespacekey', () => {
+    let storageAbstract;
+
+    beforeEach(() => {
+        storageAbstract = new StorageAbstract();
+    });
+
+    it('throws an exception when a non-string is passed', () => {
+        let keys = [true, [], {}, 1];
+        for (const key of keys) {
+            expect(() => {
+                storageAbstract.namespaceKey(key);
+            }).toThrow(KEY_IS_REQUIRED_TO_FETCH_DATA);
+        }
+    });
+
+    it('returns a concatenated variation of the namespace and string key', () => {
+        let key = 'key';
+        expect(storageAbstract.namespaceKey(key))
+            .toEqual(`${ storageAbstract.namespace }.${ key }`);
+    });
+
+    it('coerces the key to lower case before returning', () => {
+        let key = 'KEy';
+        expect(storageAbstract.namespaceKey(key))
+            .toEqual(`${ storageAbstract.namespace }.${ key.toLowerCase() }`);
+    });
+
+    it('extracts the namespace and key separator when present at the beginning of the string', () => {
+        const theRealKey = 'myrealkey';
+        let key = `${ storageAbstract.namespace }.${ theRealKey }`;
+        expect(storageAbstract.namespaceKey(key))
+            .toEqual(`${ storageAbstract.namespace }.${ theRealKey.toLowerCase() }`);
+    });
+
+    it('does not extract the namespace and key separator when present anywhere else in the string', () => {
+        const theRealKey = 'myrealkey';
+        let key = `a${ storageAbstract.namespace }.${ theRealKey }`;
+        expect(storageAbstract.namespaceKey(key))
+            .not.toEqual(`${ storageAbstract.namespace }.${ theRealKey.toLowerCase() }`);
+        expect(storageAbstract.namespaceKey(key))
+            .toEqual(`${ storageAbstract.namespace }.${ key.toLowerCase() }`);
+    });
+
+    it('does not extract the namespace when missing the key separator', () => {
+        const theRealKey = 'myrealkey';
+        let key = `${ storageAbstract.namespace }${ theRealKey }`;
+        expect(storageAbstract.namespaceKey(key))
+            .toEqual(`${ storageAbstract.namespace }.${ key.toLowerCase() }`);
+    });
+});

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

@@ -0,0 +1,36 @@
+import StorageAbstract from '../';
+
+describe('core:class >> storageabstract:parser', () => {
+    let storageAbstract;
+    const copyParse = JSON.parse;
+    delete JSON.parse;
+
+    beforeEach(() => {
+        storageAbstract = new StorageAbstract();
+        JSON.parse = jest.fn();
+        JSON.parse.mockClear();
+    });
+
+    it('returns the raw data when not a string', () => {
+        const data = {
+            my: 'value'
+        };
+
+        expect(storageAbstract.parser(data)).toEqual(data);
+        expect(JSON.parse).not.toBeCalled();
+    });
+
+    it('attempts to parse the item when it is a string', () => {
+        const data = 'somestuff';
+
+        storageAbstract.parser(data);
+        expect(JSON.parse).toHaveBeenCalledTimes(1);
+    });
+
+    it('throws an exception when string is not valid json', () => {
+        JSON.parse = copyParse;
+        expect(() => {
+            storageAbstract.parser('wowowow');
+        }).toThrow();
+    });
+});

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

@@ -0,0 +1,70 @@
+import StorageAbstract from '../';
+
+describe('core:class >> storageabstract:removeitem', () => {
+    let storageClassMock, mockStorage, key = 'test';
+
+    beforeAll(() => {
+        storageClassMock = new StorageAbstract();
+    });
+
+    beforeEach(() => {
+        storageClassMock.isSupported = jest.fn().mockImplementation(() => true);
+        storageClassMock.namespaceKey = jest.fn().mockImplementation(key => key);
+        storageClassMock.expirationKey = jest.fn().mockImplementation(key => `${key}.expires`);
+        storageClassMock.resetAttempts = jest.fn().mockImplementation(() => {
+            storageClassMock.attempts = 0;
+        });
+
+        mockStorage = {
+            removeItem: jest.fn()
+        };
+
+        storageClassMock.attempts = 0;
+        storageClassMock.storage = mockStorage;
+    });
+
+    it('resets the attempts and 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.storage.removeItem).not.toHaveBeenCalled();
+
+    });
+
+    it('attempts two times when encountering an error', () => {
+        const badStorage = {
+            removeItem: jest.fn().mockImplementation(() => {
+                throw new Error('testing code');
+            })
+        };
+
+        storageClassMock.storage = badStorage;
+        storageClassMock.removeItem();
+
+        expect(storageClassMock.storage.removeItem).toHaveBeenCalledTimes(2);
+    });
+
+    it('removes both the item at namespace and expiration keys', () => {
+        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.resetattempts.spec.js

@@ -0,0 +1,20 @@
+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);
+    });
+});

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

@@ -0,0 +1,101 @@
+import StorageAbstract from '../';
+
+describe('core:class >> storageabstract:setitem', () => {
+    let storageClassMock, mockStorage, key = 'test';
+
+    beforeAll(() => {
+        storageClassMock = new StorageAbstract();
+    });
+
+    beforeEach(() => {
+        storageClassMock.isSupported = jest.fn().mockImplementation(() => true);
+        storageClassMock.namespaceKey = jest.fn().mockImplementation(key => key);
+        storageClassMock.expirationKey = jest.fn().mockImplementation(key => key);
+        storageClassMock.translator = jest.fn().mockImplementation(data => data);
+        storageClassMock.timestamp = jest.fn().mockImplementation(() => 12345);
+        storageClassMock.cache = jest.fn().mockImplementation(data => data);
+        storageClassMock.clear = jest.fn().mockImplementation(() => storageClassMock);
+        storageClassMock.resetAttempts = jest.fn().mockImplementation(() => {
+            storageClassMock.attempts = 0;
+            return storageClassMock;
+        });
+
+        mockStorage = {
+            setItem: jest.fn()
+        };
+
+        storageClassMock.attempts = 0;
+        storageClassMock.storage = mockStorage;
+    });
+
+    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.namespaceKey).not.toHaveBeenCalled();
+    });
+
+    it('uses a dynamically generated namespaceKey to set the item', () => {
+        storageClassMock.setItem(key, { data: true });
+        expect(storageClassMock.namespaceKey).toHaveBeenCalledTimes(1);
+    });
+
+    it('calls the translator prior to attempting to set the item', () => {
+        storageClassMock.translator = jest.fn().mockImplementation(() => {
+            throw new Error('testing script error');
+        });
+
+        storageClassMock.setItem(key, { data: true });
+        expect(storageClassMock.translator).toHaveBeenCalled();
+        expect(storageClassMock.storage.setItem).not.toHaveBeenCalled();
+    });
+
+    it('calls to set the item one time when not expired', () => {
+        const data = { it: true };
+
+        storageClassMock.setItem(key, data, false);
+
+        expect(storageClassMock.storage.setItem).toHaveBeenCalledTimes(1);
+        expect(storageClassMock.storage.setItem).toHaveBeenCalledWith(key, data);
+        expect(storageClassMock.expirationKey).not.toHaveBeenCalled();
+    });
+
+    it('calls set item again with the expiration key if defaulted to expire', () => {
+        const data = { it: true };
+
+        storageClassMock.setItem(key, data);
+
+        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

@@ -0,0 +1,25 @@
+import StorageAbstract from '../';
+
+// Mocking JSON.parse failed in this version of Jest
+describe('core:class >> storageabstract:translator', () => {
+    let storageAbstract;
+
+    beforeEach(() => {
+        storageAbstract = new StorageAbstract();
+    });
+
+    it('calls json stringify when passed an object', () => {
+        const data = {
+            my: 'value'
+        };
+
+        expect(storageAbstract.translator(data))
+            .toEqual(JSON.stringify(data));
+    });
+
+    it('returns a string back exactly as is', () => {
+        const data = 'somestuff';
+
+        expect(storageAbstract.translator(data)).toEqual(data);
+    });
+});

package/lib/abstract/constants/index.js

@@ -0,0 +1,3 @@
+export const DEFAULT_EXPIRATION = 3600;
+export const DEFAULT_NAMESPACE = 'bizj';
+export const EXPIRES_KEY_SUFFIX = 'expires';

package/lib/abstract/exceptions/index.js

@@ -0,0 +1 @@
+export const KEY_IS_REQUIRED_TO_FETCH_DATA = 'A key must be provided to obtain data from the store.';

package/lib/abstract/index.js

@@ -0,0 +1,293 @@
+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
+|--------------------------------------------------------------------------
+|
+| This is the base storage class that is extended for localStorage and
+| sessionStorage. In time we may look to use this for InnoDB as well.
+|
+|
+*/
+export default class StorageAbstract {
+    /**
+     * Constructor takes in options for namespace and expiration.
+     * Session storage is the default storage type.
+     *
+     * @param {object} options
+     * @constructor
+     */
+    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.
+     *
+     * @param {string} key
+     * @returns {(Array|Number|Object|String)}
+     */
+    getItem(key) {
+        if (!this.isSupported() || this.isItemExpired(key)) {
+            return null;
+        }
+
+        let response = null;
+
+        if (cache[this.namespace][key]) {
+            return cache[this.namespace][key];
+        }
+
+        try {
+            const generatedKey = this.namespaceKey(key);
+
+            response = this.parser(cache[generatedKey] || this.storage.getItem(generatedKey));
+
+            this.cache(key, response);
+        } catch (e) {
+            // fall through
+        }
+
+        return response;
+    }
+
+    /**
+     * Parses the data returned from the storage system
+     *
+     * @param data
+     * @returns {any}
+     */
+    parser(data) {
+        return typeof data === "string" ? JSON.parse(data) : data;
+    }
+
+    /**
+     * Translates the data before setting to the storage system
+     *
+     * @param value
+     * @returns {any}
+     */
+    translator(value) {
+        return typeof value === "string" ? value : JSON.stringify(value);
+    }
+
+    /**
+     * Sets an item in the storage system.
+     *
+     * @param {string} key
+     * @param {(array|object|number|string)} value
+     * @param {boolean} expires
+     */
+    setItem(key, value, expires = true) {
+        if (!this.isSupported() || this.attempts >= 2) {
+            return this.resetAttempts();
+        }
+
+        const generatedKey = this.namespaceKey(key);
+
+        try {
+            this.storage.setItem(generatedKey, this.translator(value));
+
+            if (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);
+        }
+
+        return this.resetAttempts();
+    }
+
+    /**
+     * Removes an item from the storage system.
+     *
+     * @param {string} key
+     */
+    removeItem(key) {
+        if (!this.isSupported() || this.attempts >= 2) {
+            return this.resetAttempts();
+        }
+
+        try {
+            this.storage.removeItem(this.namespaceKey(key));
+            this.storage.removeItem(this.expirationKey(key));
+
+            this.free(key);
+        } catch (e) {
+            this.attempts++;
+            this.removeItem(key);
+        }
+
+        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() {
+        try {
+            this.storage.clear();
+
+            cache[this.namespace] = {};
+        } catch (e) {
+            // fall through
+        }
+
+        return this;
+    }
+
+    /**
+     * Checks to see if an item exists in local storage.
+     *
+     * @param {string} key
+     * @returns {boolean}
+     */
+    hasItem(key) {
+        return !empty(this.getItem(key));
+    }
+
+    /**
+     * Calculates the expires for an item.
+     *
+     * @param {number} offset
+     * @returns {number}
+     */
+    timestamp(offset = 0) {
+        return Math.ceil(Date.now() / 1000) + offset;
+    }
+
+    /**
+     * Creates the key used for storing information in the storage
+     *
+     * @param {string} key
+     * @returns {string}
+     */
+    namespaceKey(key) {
+        if (typeof key !== "string") {
+            throw new Error(KEY_IS_REQUIRED_TO_FETCH_DATA);
+        }
+
+        if (key.indexOf(`${this.namespace}.`) === 0) {
+            key = key.slice(this.namespace.length + 1);
+        }
+
+        return `${this.namespace}.${key.toLowerCase()}`;
+    }
+
+    /**
+     * Creates the expires key used for testing storage usage
+     *
+     * @returns {string}
+     */
+    expirationKey(key) {
+        return `${this.namespaceKey(key)}.${EXPIRES_KEY_SUFFIX}`;
+    }
+
+    /**
+     * Checks to see if an item is expired and removes it if so.
+     *
+     * @param {string} key
+     * @returns {boolean}
+     */
+    isItemExpired(key) {
+        if (!this.isSupported()) {
+            return false;
+        }
+
+        try {
+            let value = this.storage.getItem(this.expirationKey(key));
+
+            if (value && "length" in value && value.length) {
+                let expires = parseInt(value, 10);
+
+                if (expires - this.timestamp() <= 0) {
+                    this.removeItem(key);
+                    return true;
+                }
+            }
+        } catch (e) {
+            // fall through
+        }
+
+        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;
+        }
+
+        const test = `${this.namespaceKey("storage")}.test`;
+
+        try {
+            this.storage.setItem(test, test);
+            this.storage.removeItem(test);
+            this.storage._supported = true;
+        } catch (e) {
+            this.storage._supported = false;
+        }
+
+        return this.storage._supported;
+    }
+}

package/lib/local/__mocks__/local-storage.js

@@ -0,0 +1,28 @@
+import StorageAbstract from '../../abstract';
+
+export default class LocalStorageMock extends StorageAbstract {
+    constructor (options) {
+        super(options);
+        this.store = {};
+    }
+
+    clear () {
+        this.store = {};
+    }
+
+    getItem (key) {
+        return this.store[key] || null;
+    }
+
+    setItem (key, value, expires = true) {
+        this.store[key] = value;
+        return this;
+    }
+
+    removeItem (key) {
+        delete this.store[key];
+        return this;
+    }
+}
+
+export class InvalidStorageMock {}

package/lib/local/__tests__/storage.local.spec.js

@@ -0,0 +1,8 @@
+import LocalStorage from '../';
+
+describe('bizjournals / core:class >> localstorage:constructor', () => {
+    it('builds the object with localStorage set as the storage system', () => {
+        const localStorage = new LocalStorage();
+        expect(localStorage.storage).toEqual(window.localStorage);
+    });
+});

package/lib/local/index.js

@@ -0,0 +1,24 @@
+import StorageAbstract from "../abstract";
+
+/*
+|--------------------------------------------------------------------------
+| Local Storage
+|--------------------------------------------------------------------------
+| This is the base class for hooking into local storage. There isn't much
+| overlap here if you just keep instantiating, so there isn't much need
+| to singleton this.
+|
+|
+*/
+export default class LocalStorage extends StorageAbstract {
+    /**
+     * Create a local storage adapter.
+     *
+     * @param {object} [options]
+     */
+    constructor(options = {}) {
+        super(options);
+
+        this.storage = window.localStorage;
+    }
+}

package/lib/reference/__tests__/storagereference.general.spec.js

@@ -0,0 +1,47 @@
+import StorageReference from '../';
+import LocalStorageMock, { InvalidStorageMock } from '../../local/__mocks__/local-storage';
+import { INVALID_CONSTRUCTOR_PARAMETERS } from '../exceptions';
+
+describe('bizjournals / core:class >> storagereference', () => {
+    it('throws error when the cachekey is not a string', () => {
+        expect(() => {
+            new StorageReference([], new LocalStorageMock());
+        }).toThrow(INVALID_CONSTRUCTOR_PARAMETERS);
+    });
+
+    it('throws an error when the storage system does not adhere to contract', () => {
+        expect(() => {
+            new StorageReference('astring', new InvalidStorageMock());
+        }).toThrow(INVALID_CONSTRUCTOR_PARAMETERS);
+    });
+
+    it('does not throw an error when constructor parameters are valid', () => {
+        expect(() => {
+            new StorageReference('astring', new LocalStorageMock());
+        }).not.toThrow();
+    });
+
+    it('assigns the constructor parameters to variables for reference', () => {
+        const cacheKey = 'astring';
+        const localStorage = new LocalStorageMock();
+
+        const storage = new StorageReference(cacheKey, localStorage);
+
+        expect(storage.cacheKey).toEqual(cacheKey);
+        expect(storage.storageSystem).toEqual(localStorage);
+    });
+
+    it('can save and obtain the data using the key from storage', () => {
+        const cacheKey = 'astring';
+        const localStorage = new LocalStorageMock();
+        const mockData = { luke: 'skywalker', plot: 'ruined' };
+
+        const storage = new StorageReference(cacheKey, localStorage);
+
+        expect(() => {
+            storage.saveAs(mockData);
+        }).not.toThrow();
+
+        expect(storage.obtain()).toEqual(mockData);
+    });
+});

package/lib/reference/exceptions/index.js

@@ -0,0 +1 @@
+export const INVALID_CONSTRUCTOR_PARAMETERS = 'Invalid construction of cache system. Please refer to documentation.';

package/lib/reference/index.js

@@ -0,0 +1,67 @@
+import StorageAbstract from "../abstract";
+import { INVALID_CONSTRUCTOR_PARAMETERS } from "./exceptions";
+
+/*
+|--------------------------------------------------------------------------
+| Storage Reference
+|--------------------------------------------------------------------------
+| This is a reference to something in storage. Each item has a key
+| belonging to a specific storage system. These storage systems have a
+| common abstract / contract that gives them the same expected pattern.
+| This is the adapter.
+|
+|
+*/
+export default class StorageReference {
+    /**
+     * Creates an instance of a StorageReference system, which needs a cacheKey and
+     * a Storage system (StorageAbstract).
+     *
+     * @param {string} cacheKey
+     * @param {StorageAbstract} storageSystem
+     * @constructor
+     * @return {StorageReference}
+     */
+    constructor(cacheKey, storageSystem) {
+        if (typeof cacheKey !== "string" || !(storageSystem instanceof StorageAbstract)) {
+            throw new Error(INVALID_CONSTRUCTOR_PARAMETERS);
+        }
+
+        this.cacheKey = cacheKey;
+        this.storageSystem = storageSystem;
+    }
+
+    /**
+     * Pulls data from the local store or cached resource.
+     *
+     * @returns {*}
+     */
+    obtain() {
+        return this.storageSystem.getItem(this.cacheKey);
+    }
+
+    /**
+     * Destroys the cache reference with the cache key
+     *
+     * @returns {void}
+     */
+    bust() {
+        this.storageSystem.removeItem(this.cacheKey);
+    }
+
+    /**
+     * Saves the locally stored cache to the caching system. This is
+     * differed via a Promise because the timing of this can be
+     * performed asynchronously.
+     *
+     * @param data
+     * @returns {StorageReference}
+     */
+    saveAs(data) {
+        if (data) {
+            this.storageSystem.setItem(this.cacheKey, data);
+        }
+
+        return this;
+    }
+}

package/lib/session/__tests__/storage.session.spec.js

@@ -0,0 +1,8 @@
+import SessionStorage from "../";
+
+describe("bizjournals / core:class >> sessionstorage:constructor", () => {
+    it("builds the object with sessionStorage set as the storage system", () => {
+        const sessionStorage = new SessionStorage();
+        expect(sessionStorage.storage).toEqual(window.sessionStorage);
+    });
+});

package/lib/session/index.js

@@ -0,0 +1,24 @@
+import StorageAbstract from "../abstract";
+
+/*
+|--------------------------------------------------------------------------
+| Session Storage
+|--------------------------------------------------------------------------
+| This is the base class for hooking into session storage. There isn't much
+| overlap here if you just keep instantiating, so there isn't much need
+| to singleton this.
+|
+|
+*/
+export default class SessionStorage extends StorageAbstract {
+    /**
+     * Create a session storage adapter.
+     *
+     * @param {object} [options]
+     */
+    constructor(options) {
+        super(options);
+
+        this.storage = window.sessionStorage;
+    }
+}

package/main.js

@@ -0,0 +1,5 @@
+import LocalStorage from "./lib/local";
+import SessionStorage from "./lib/session";
+import StorageReference from "./lib/reference";
+
+export { LocalStorage, SessionStorage, StorageReference };

package/package.json

@@ -0,0 +1,25 @@
+{
+    "name": "@bizjournals/js-storage",
+    "version": "0.0.1",
+    "description": "ACBJ javascript storage classes",
+    "repository": {
+        "git": "https://gitlab.bizjournals.com/bizjournals/js-storage"
+    },
+    "main": "main.js",
+    "type": "module",
+    "sideEffects": false,
+    "scripts": {
+        "test": "jest --transformIgnorePatterns \"node_modules/(?!(@bizjournals))/\""
+    },
+    "keywords": [],
+    "author": "DPD",
+    "license": "UNLICENSED",
+    "devDependencies": {
+        "@babel/preset-env": "^7.9.5",
+        "babel-jest": "^25.4.0",
+        "jest": "^25.4.0"
+    },
+    "dependencies": {
+        "@bizjournals/js-utilities": "0.0.1"
+    }
+}