DBMagic

const log = console.log;

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

class Table {
  constructor( db, name) {
    this.db = db;
    this.name = name;
    this.debug = db.debug;
    this.limitSize = 0;
  }

  limit( limit ) {
    this.limitSize = limit;
    return this;
  }

  orderby( keys, mode = 'asc' ) {
    this.order = ( mode === 'asc' ? true : false );
    this.orderby = Array.isArray( keys ) ? keys : [ keys ];
    return this;
  }

  async transaction( store, mode ) {
    const db = this.db.name;

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

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

      openReq.onsuccess = () => {
        const tx = openReq.result.transaction ( [ store ], mode );
        resolve( tx );
        openReq.result.close();
      };
    } );
  }

  async add( args, opt=false ) {
    const db = this.db.name;

    if ( ! Array.isArray( args ) ) args = [ args ];

    const stores = await this.db.stores();
    const version = await this.db.version();
    const create_store = ! stores.contains( this.name );

    let promise = false;

    if ( create_store ) {
      promise = new Promise( ( resolve, reject ) => {
        let req = indexedDB.open( db, version + 1 );

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

    if ( promise ) await promise;

    let promises = [];

    return new Promise( ( resolve, reject ) => {
      args.forEach( item => { promises.push( this.que_add( item, opt ) ); } );
      Promise.all( promises )
      .then( () => resolve( this ) )
      .catch( err => reject( err ) );
    } );
  }

  async get( args ) {
    const sortColumns = ( arr, props, mode = true ) => {
      if ( ! Array.isArray( props ) ) props = [ props ];

      const sorted = arr.sort( ( a, b ) => {
        let prop = props[ 0 ];
        for ( let idx = 0; idx < props.length; idx++ ) {
          const curProp = props[ idx ];
          if ( a[ curProp ] !== b[ curProp ] ) {
            prop = curProp;
            break;
          }
        }
        if ( a[ prop ] === b[ prop ] ) return 0;
          return ( a[ prop ] > b[ prop ] ? -1 : 1 ) * ( mode ? -1 : 1 );
      } );
      return sorted;
    };

    const db = this.db.name;
    const stores = await this.db.stores();
    if ( ! stores.contains( this.name ) ) return false;

    if ( ! Array.isArray( args ) ) args = [ args ];

    let promises = [];
    return new Promise( ( resolve, reject ) => {
      if ( args )
        args.forEach( item => { promises.push( this.que_get( item) ); } );
      else
        promises.push( this.que_get() );

      Promise.all(promises)
      .then( results => {
        if ( results.length ) {
          if ( this.limitSize )
            results = [ results[ 0 ].slice( 0, this.limitSize ) ];
          results = sortColumns( results[ 0 ], this.orderby, this.order );
        }
        this.limitSize = 0;
        resolve( results );
      } )
      .catch( err => reject( err ) );
    } );
  }

  async update( args ) {
    const db = this.db.name;
    const stores = await this.db.stores();
    if ( ! stores.contains( this.name ) ) return false;

    let promises = [];

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

      args.forEach( item => { promises.push( this.que_update( item ) ); } );
      Promise.all( promises )
      .then( () => resolve( this ) )
      .catch( err => reject( err ) );
    } );
  }

  async delete() {
    const db = this.db.name;
    const stores = await this.db.stores();
    const version = await this.db.version();

    return new Promise( ( resolve, reject ) => {
      var req = indexedDB.open( this.db.name, version + 1  );

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

        req.onsuccess = ( ) => { req.result.close(); resolve( this ); };

        req.onupgradeneeded = () => {
          req.result.deleteObjectStore( this.name );
        };
    } );
  }

  async que_add( args, opt=false ) {
    const db = this.db.name;
    const tx = await this.transaction( [ this.name ], 'readwrite' );

    return new Promise(( resolve, reject ) => {
      let addReq = tx.objectStore( this.name ).add( args );

      addReq.onerror = e => {
        if ( this.debug ) {
          const err = opt ? 'WARN' : 'ERROR';
          const msg = `[ ${ err }:add ], could not add key [${ args.id
          }] in store [${  addReq.source.name }] in database [${ db }], ` +
          e.target.error;
          log( msg );
        }
        opt ? resolve( this ) : reject( e );
      };

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

  async que_get( args ) {
    const db = this.db.name;
    const tx = await this.transaction( [ this.name ], 'readonly' );

    return new Promise( ( resolve, reject ) => {
      let obj = tx.objectStore( this.name );
      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 [${ db }]` );
        reject( e );
      };

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

        const result = ! Array.isArray( req.result ) ?
        [ req.result ] : req.result;
        resolve( result );
      };
    } );
  }

  async que_update( args ) {
    const db = this.db.name;

    const values = await this.get( { id: args.id } );
    if ( ! values.length ) return this;

    args = { ...values[0], ...args };

    const tx = await this.transaction( [ this.name ], 'readwrite' );
    return new Promise(( resolve, reject ) => {
        let addReq = tx.objectStore( this.name ).put( args );

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

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

export default class DBMagic {
  constructor( name ) {
    this.name = name;
    this.debug = false;
    this.tables = {};
    this.init();
  }

  init() {
    Object.values( this.stores() ).forEach( name => this.table( name ) );
  }

  table( name ) {
    let args = {}
    if ( ! ( name in this.tables ) ) {
      this.tables[ name ] = new Table( this, name, args );
    }
    return this.tables[ name ];
  }

  config( args ) {
    for (var key in args )
      this[ key ] = args[ key ];
    return this;
  }

  delete( args ) {
    if ( args ) {
      if ( ! Array.isArray( args ) ) args = [ args ];

      args.forEach( store => {
        if ( store in this.tables ) {
          this.tables[ store ].delete();
          delete this.tables[ store ];
        }
      } );
    } else {
      return new Promise( ( resolve, reject ) => {
        var req = indexedDB.deleteDatabase( this.name );

        req.onerror = err => { reject( err ); };

        req.onsuccess = () => {
          if( this.debug )
            log( '[INFO:delete], Deleted database [' + this.name + ']');

          this.tables = {};
          resolve( this );
        };
      } );
    }
  }

  stores() {
    return new Promise( ( resolve, reject ) => {
      var req = indexedDB.open( this.name );

      req.onerror = err => { reject( err ); };

      req.onsuccess = () => {
        let names = req.result.objectStoreNames;
        if( this.debug )
          log( '[INFO:db_version], Database [' + this.name +
          '], version []');

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

      req.onupgradeneeded = () => { return true; };
    } );
  }

  version() {
    const db = this.name;
    return new Promise( ( resolve, reject ) => {
      var req = indexedDB.open( db );

      req.onerror = err => { reject( err ); };

      req.onsuccess = () => {
        let version = req.result.version;
        if( this.debug )
          log( '[INFO:db_version], Database [' + db +
          '], version [' + version + ']');

        req.result.close();
        resolve( version );
      };
      req.onupgradeneeded = () => { return true; };
    } );
  }
}