DBMagic

class DBMagic {
  constructor( db_name, db_version, db_stores, defaults, debug = false ) {
    return new Promise( ( resolve, reject ) => {

      this.db = false;
      this.debug = debug;
      this.indexedDB = window.indexedDB || window.mozIndexedDB ||
      window.webkitIndexedDB || window.msIndexedDB;

      if ( defaults ) this.db_delete( db_name );

      this.db_create( db_name, db_version, db_stores )
      .then( () => { resolve( this ); } )
      .catch( err => {
        if ( debug )
          log( 'ERROR: [DBMagic] Could not open database [' +
          db_name + '].', err );
        reject( err );
      } );
    } );
  }

  req( name, mode) {
    return new Promise( ( resolve, reject ) => {
      let req = this.indexedDB.open( this.db.name, this.db.version );
      req.onerror = ( e ) => {
        reject( e );
      };
      req.onsuccess = ( e ) => {
        let db = req.result;
        if (! db.objectStoreNames.contains( name ) ) {

          if ( this.debug )
            log( `ERROR: [add] store name [${
            name }] was not found in database [${ this.db.name }]` );
          reject( e );
        } else {
          let tx = db.transaction ( [ name ], mode );
          let st = tx.objectStore( name ) ;
          resolve( st );
          return st;
        }
      };
    } );
  }

  add( name, item ) {
    return new Promise( ( resolve, reject ) => {
      this.req( name, 'readwrite' ).then( store => {
        item.timestamp = new Date();
        let req = store.add( item );
        req.onerror = ( e ) => {
          if ( this.debug )
            log( `ERROR: Adding key [${ item.id }] to store [${
            name }] on database [${ this.db.name }]` );
          reject( e );
        };
        req.onsuccess = () => {
          if ( this.debug )
            log( `INFO: Added key [${ item.id }] to store [${
            name }] on database [${ this.db.name }]` );
            resolve( item );
        };
      } ).catch( err => { reject( err ); } );
    } );
  }

  get( name, key ) {
    return new Promise( ( resolve, reject ) => {
      this.req( name, 'readwrite' ).then( store => {
        let req = store.get( key );
        req.onerror = ( e ) => {
          if ( this.debug )
            log( `ERROR: [get] Could not retrieve key [${ key }] from store [${
            name }] in database [${ this.db.name }]` );
          reject( e );
        };
        req.onsuccess = ( e ) => {
          if ( typeof e.target.result === 'undefined' ) {
            req.onerror( e );
          } else {
            if ( this.debug )
              log( `INFO: [get] Retrieved key [${ key }] from store [${
              name }] in database [${ this.db.name }]` );
            resolve( e.target.result );
          }
        };
      } ).catch( err => { reject( err ); } );
    } );
  }

  getAll( name ) {
    return new Promise( ( resolve, reject ) => {
      this.req( name, 'readonly' ).then( store => {

        let req = store.getAll();
        req.onerror = ( e ) => {
          if ( this.debug )
            log( 'ERROR: [getAll] Could not retrieve keys from store [' +
            name + ' on database' + this.db.name +']', e.srcElement.error );
          reject( e );
        };
        req.onsuccess = ( e ) => {
          if ( this.debug )
            log( 'INFO: Retrieved all keys from store [' + name +
            '] on database ['+ this.db.name +']' );
          resolve( req.result );
        };
      } ).catch( ( e ) => {
        if ( this.debug )
          log( 'ERROR: [getAll] Store [' + name +
          '] not found in database [' + this.db.name + "]" );
        reject( e );
      } );
    } );
  }

  update( name, item ) {
    return new Promise( ( resolve, reject ) => {
      this.req( name, 'readwrite' )

      .then( store => {
        let req = store.put( item );
        req.onerror = ( e ) => {
          if ( this.debug )
            log( 'ERROR: Updating key [' + item.id + '] in store [' +
            name + '] on database [' + this.db.name + ']',
            e.srcElement.error );
          reject( e );
        };
        req.onsuccess = ( e ) => {
          if ( this.debug )
            log( 'INFO: Updated key ['+ item.id +'] in store [' +
            name + '] on database [' + this.db.name + ']', item );
          resolve( item );
        };
      });
    } )

    .catch( ( e ) => {
      if ( this.debug )
        log( 'ERROR: [update] Store [' + name +
        '] not found in database [' + this.db.name + "]" );
      reject( e );
    } );
  }

  delete( name, items ) {
    if ( typeof items === 'string' ) items = [ items ];

    return new Promise( ( resolve, reject ) => {
      this.store( name, 'readwrite' ).then( store => {
        items.forEach( item => {
          const req = store.delete( item );
          req.onerror = ( e ) => {
            if ( this.debug )
              log( 'ERROR: Deleted key [' + item + '] from store [' +
              name + ']', e.srcElement.error );
            reject( e );
          };
          req.onsuccess = ( e ) => {
            if ( this.debug )
              log( 'SUCCESS: Deleted key [' + item + '] from store [' +
              name + '] on database [' + this.db.name + ']' );
            resolve( e );
          };
        } );
      } ).catch( () => {
        if ( this.debug )
          log( 'ERROR: [delete] Store [' + name +
          '] not found in database [' + this.db.name + "]" );
      } );
    } );
  }

  deleteAll( name ) {
    return new Promise( ( resolve, reject ) => {
      this.store( name, 'readwrite' ).then( store => {
        const req = store.clear();
        req.onerror = ( e ) => {
          if ( this.debug )
            log( 'ERROR: Could not delete keys from store [' + name +
            '] on database [' + this.db.name + ']', e.srcElement.error );
          reject( e );
        };
        req.onsuccess = ( e ) => {
          if ( this.debug )
            log( 'SUCCESS: Deleted all keys from store [' +
            name + '] on database [' + this.db.name + ']' );
          resolve( e );
        };
      }).catch( () => {
        if ( this.debug )
          log( 'ERROR: [deleteAll] Store [' + name +
          '] not found in database [' + this.db.name + "]" );
      } );
    } );
  }

  db_delete( db_name ) {
    if ( ! db_name ) return;

    this.indexedDB.deleteDatabase( db_name );

    return new Promise( ( resolve, reject ) => {
      if ( this.debug )
        log('INFO: Database ['+ db_name +'] deleted successfully.');
      resolve( true );
    } );
  }

  db_create( db_name, db_version, stores ) {
    if ( this.db ) return this.db;

    return new Promise( ( resolve, reject ) => {
      let req = this.indexedDB.open( db_name, db_version );
      req.onerror = ( e ) => {
        if ( this.debug )
          log( `ERROR: Opening database [${ db_name }]` );
        reject( e );
      };

      req.onsuccess = ( e ) => {
        if ( this.debug )
          log( `INFO: Opened database [${ db_name }]` );
        this.db = req.result;
        resolve( req.result );
      };

      req.onupgradeneeded = ( e ) => {
        let db = req.result;
        log( `INFO: Created database [${ db_name }]` );

        switch( e.oldVersion ) {
          case 0:
            stores.forEach( name => {
              db.createObjectStore( name, { keyPath: 'id' } );
//              this.db_stores.push( name );
              if ( this.debug )
                log( `INFO: Store [${name}] created on database [${ db_name }]` );
            } );
          default:
            if ( this.debug )
              log( 'INFO: Version change, Old version [' + e.oldVersion +
              '], New version [' + e.newVersion + ']' );
          break;
        }
      };
    } );
  }
}