IndexedDB.js

var idb = (function () {
    'use strict';

    var IDB = window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
    var IDBTransactionMode = {
        readOnly: 'readonly',
        readWrite: 'readwrite',
        versionChange: 'versionchange'
    };

    var DB_NAME = 'KeyValueDB';
    var STORE_NAME = 'KeyValueStore';
    var VERSION = 1;
    var db, store, q = [];
    
    var toArray = (function () {
        var slice = Array.prototype.slice;
        return function (arrayLike, begin, end) {
            return slice.call(arrayLike, begin, end);
        };
    }());

    var dbOpenRequest = IDB.open(DB_NAME, VERSION);
    dbOpenRequest.onerror = onDbOpenError;
    dbOpenRequest.onsuccess = onDbOpenSuccess;
    dbOpenRequest.onupgradeneeded = onDbOpenUpgradeNeeded;
    
    function onDbOpenError(event) {
        console.log('dbOpenRequest.onerror', event);
    }

    function onDbOpenSuccess(event) {
        console.log('dbOpenRequest.onsuccess', event);
        db = event.target.result;
    }

    function onDbOpenUpgradeNeeded(event) {
        console.log('dbOpenRequest.onupgradeneeded', event);
        var db = event.target.result;
        var store = db.createObjectStore(STORE_NAME, { keyPath: 'key' });
        store.createIndex('key', 'key', { unique: true });
        store.createIndex('index', 'index', { unique: true });
        store.createIndex('value', 'value', { unique: false });
        store.transaction.oncomplete = onStoreCreatedComplete;
    }

    function onStoreCreatedComplete(event) {
        console.log('store.transaction.oncomplete', event);
        var transaction = db.transaction(STORE_NAME, IDBTransactionMode.readWrite);
        var store = transaction.objectStore(STORE_NAME);
        flushQueue();
    }

// store.add(key, value)
// store.delete(key)
// store.get(key)
// store.put(key)
// store.clear()
    
    return {
        // NOTE! This is a function! Resolves with an integer representing the number of data items stored in the Storage object.
        length: callbackPromise(function (callback) {
            queue(function (store) {
                var request = store.count();
                bindHandlers(request, callback);
            });
        }),

        // When passed a key name, will resolve with that key's value.
        get: function (key, callback) {
            throw new Error('Not implemented yet');
        },

        // Will resolve with all items in the store.
        getAll: function (callback) {
            throw new Error('Not implemented yet');
        },

        // When passed a key name and value, will add that key to the storage, or update that key's value if it already exists.
        set: function (key, value, callback) {
            throw new Error('Not implemented yet');
        },

        // When passed a key name, will remove that key from the storage.
        remove: function (key, callback) {
            throw new Error('Not implemented yet');
        },

        // When invoked, will empty all keys out of the storage.
        clear: function (callback) {
            throw new Error('Not implemented yet');
        }
    };
    
    function queue(fn) {
        store ? fn(store) : q.push(fn);
    }
    
    function flushQueue() {
        for (var i = 0, l = q.length; i < l; i++) {
            q[i](store);
        }
        q.length = 0;
    }
    
    function bindHandlers(dbRequest, callback) {
        dbRequest.onsuccess = function (event) {
            console.log('dbRequest.onsuccess', event);
            callback(null, dbRequest.result);
        };
        dbRequest.onerror = function (event) {
            console.log('dbRequest.onerror', event);
            callback(dbRequest.result);
        };
    }
    
    function callbackPromise(fn) {
        return function () {
            var args = toArray(arguments);
            var callback = args[args.length - 1];
            return isFunction(callback) ? apply(fn, args) : new Promise(executor(fn, args));
        };
    }
    
    function executor(fn, args) {
        return function (resolve, reject) {
            args.push(callback);
            apply(fn, args);
            function callback(error, result) {
                if (error) {
                    reject(error);
                } else {
                    resolve(result);
                }
            }
        };
    }
    
    /**
     * @params {Function} fn
     * @params {any} [...rest]
     * @returns {Function}
     */
    function partial(fn, rest) {
        rest = toArray(arguments, 1);
        return partialArgs(fn, rest);
    }
    
    /**
     * @params {Function} fn
     * @params {Array} args
     * @returns {Function}
     */
    function partialArgs(fn, args) {
        return function () {
            return fn.apply(null, args.concat(toArray(arguments)));
        };
    }
    
    function apply(fn, args) {
        return fn.apply(null, args);
    }

    function isFunction(value) {
        return typeof value === 'function';
    }

}());