DBMagic Lib

const log = console.log;

class Table {
  constructor( db, name, debug=false) {
    this.db = db;
    this.dbName = db.db;
    this.store = name;
    this.debug = debug;

    this.indexedDB = window.indexedDB || window.mozIndexedDB ||
    window.webkitIndexedDB || window.msIndexedDB;

    return this.table( name );
  }

  table( store ) {
    let stores = this.db.stores;

    const do_upgrade = () => {
      stores.push( store );

      return new Promise( ( resolve, reject ) => {

        let req = this.indexedDB.open( this.dbName, stores.length + 1 );

        req.onerror = e => reject( e );
        req.onsuccess = () => {
          this.db.stores.push( store );
          req.result.close();
          resolve( this );
        };
        req.onupgradeneeded = () => req.result
        .createObjectStore( store, { keyPath: 'id' } );
      } );
    };

    return new Promise( ( resolve, reject ) => {
     let openReq = this.indexedDB.open( this.dbName );

      openReq.onerror = () => {
        do_upgrade();
        resolve( this );
      };

      openReq.onsuccess = () => {
        openReq.result.close();
        if ( ! stores.includes( store ) ) {
          do_upgrade();
        }
        resolve( this );
      };
    } );
  }

  que_add( args ) {
    return new Promise(( resolve, reject ) => {
      let openReq = this.indexedDB.open( this.dbName );

      openReq.onerror = e => reject( e );

      openReq.onsuccess = () => {
        let tx = openReq.result.transaction ( [ this.store ], 'readwrite' );
        let addReq = tx.objectStore( this.store ).add( args );
        tx.commit();

        addReq.onerror = e => {
          if ( this.debug )
            log( `[ ERROR:add ], could not add key [${ args.id }] in store [${
            addReq.source.name }] in database [${ this.dbName }]` );
          reject( e );
        };

        addReq.onsuccess = () => {
          if ( this.debug )
            log( `[ INFO:add ], Added key [${ args.id }] in store [${
            addReq.source.name }] in database [${ this.dbName }]` );
          resolve( this );
          openReq.result.close();
        };
      };
    } );
  }

  que_get( args ) {
    let store = this.store;
    let dbName = this.dbName;

    return new Promise( ( resolve, reject ) => {
      var openReq = this.indexedDB.open( dbName );

        openReq.onerror = e => reject( e );

        openReq.onsuccess = () => {
          let tx = openReq.result.transaction ( [ store ], 'readonly' );

          let obj = tx.objectStore( store );
          let req = args ? obj.get( args.id ) : obj.getAll();
          req.onerror = e => {
            if ( this.debug )
              log( `[ ERROR:getAll ], could not retrieve keys from store [${
              req.source.name }] in database [${ dbName }]` );
            reject( e );
          };

          req.onsuccess = () => {
            if ( this.debug )
              log( `[ INFO:getAll ], Retrieved all keys from store [${
              req.source.name }] in database [${ dbName }]` );

            resolve( req.result );
            openReq.result.close();
          };
        };
    } );
  }

  que_update( args ) {
    return this.get( { id: args.id } ).then( values => {
      Object.keys( values ).forEach( key => {
        if ( ! key in args ) args[ key ] = values[ key ]
      } );

      return new Promise(( resolve, reject ) => {
        let openReq = this.indexedDB.open( this.dbName );

        openReq.onerror = e => reject( e );

        openReq.onsuccess = () => {
          let tx = openReq.result.transaction ( [ this.store ], 'readwrite' );

          let addReq = tx.objectStore( this.store ).put( args );
          tx.commit();

          addReq.onerror = e => {
            if ( this.debug )
              log( `[ ERROR:add ], could not update key [${ args.id }] in store [${
              addReq.source.name }] in database [${ this.dbName }]` );
            reject( e );
          };

          addReq.onsuccess = () => {
            if ( this.debug )
              log( `[ INFO:update ], Updated key [${ args.id }] in store [${
              addReq.source.name }] in database [${ this.dbName }]` );

            openReq.result.close();
            resolve( this );
          };
        };
      } );
    } );
  }

  que_delete( args ) {
    let store = this.store;
    let dbName = this.dbName;

    return new Promise( ( resolve, reject ) => {
      var openReq = this.indexedDB.open( dbName );

        openReq.onerror = e => reject( e );

        openReq.onsuccess = () => {
          let tx = openReq.result.transaction ( [ store ], 'readwrite' );

          let obj = tx.objectStore( store );
          let req = tx.objectStore( store ).delete( args.id );
          req.onerror = e => {
            if ( this.debug )
              log( `[ ERROR:delete ], could not delete keys in store [${
              req.source.name }] in database [${ dbName }]` );
            reject( e );
          };

          req.onsuccess = () => {
            if ( this.debug )
              log( `[ INFO:delete ], Deleted keys in store [${
              req.source.name }] in database [${ dbName }]` );

            openReq.result.close();
            resolve();
          };
        };
    } );
  }

  add( args ) {
    let promises = [];
    return new Promise( ( resolve, reject ) => {
      if ( ! Array.isArray( args ) ) args = [ args ];
      args.forEach( item => { promises.push( this.que_add( item ) ); } );
      Promise.all(promises)
      .then( () => resolve( this ) )
      .catch( err => reject( err ) );
    } );
  }

  get( args ) {
    let promises = [];
    return new Promise( ( resolve, reject ) => {
      if ( ! Array.isArray( args ) ) args = [ args ];
      args.forEach( item => { promises.push( this.que_get( item ) ); } );
      Promise.all(promises)
      .then( results => resolve( results ) )
      .catch( err => reject( err ) );
    } );
  }

  update( args ) {
    let promises = [];
    return new Promise( ( resolve, reject ) => {
      if ( ! Array.isArray( args ) ) args = [ args ];;
      args.forEach( item => { promises.push( this.que_update( item ) ); } );
      Promise.all(promises)
      .then( () => resolve( this ) )
      .catch( err => reject( err ) );
    } );
  }

  delete( args ) {
    let promises = [];
    return new Promise( ( resolve, reject ) => {
      if ( ! Array.isArray( args ) ) args = [ args ];
      args.forEach( item => { promises.push( this.que_delete( item ) ); } );
      Promise.all(promises)
      .then( () => resolve( this ) )
      .catch( err => reject( err ) );
    } );
  }
}

export default class DBMagic {
  constructor( name, debug=false) {
    this.db = name;
    this.debug = debug;
    this.stores = [];
    this.upgrade = false;
    this.init();
  }

  init() {
    let indexedDB = window.indexedDB || window.mozIndexedDB ||
    window.webkitIndexedDB || window.msIndexedDB;

    return new Promise( ( resolve, reject ) => {
      let req = indexedDB.open( this.db );

      req.onerror = e => reject( e );
      req.onsuccess = () => { req.result.close(); resolve(); };
      req.onupgradeneeded = () => { return true; };
    } );
  }

  table( name ) {
    let tbl = new Table( this, name, this.debug );

    return tbl;
  }
}