chore(platform): move plugins to platform

ionic/platform/storage/sql.ts

@@ -0,0 +1,180 @@
+import {StorageEngine} from './storage';
+
+import * as util from 'ionic/util';
+
+const DB_NAME = '__ionicstorage';
+
+/**
+ * SqlStorage uses SQLite or WebSQL (development only!) to store data in a
+ * persistent SQL store on the filesystem.
+ *
+ * This is the preferred storage engine, as data will be stored in appropriate
+ * app storage, unlike Local Storage which is treated differently by the OS.
+ */
+export class SqlStorage extends StorageEngine {
+  static BACKUP_LOCAL =  2
+  static BACKUP_LIBRARY = 1
+  static BACKUP_DOCUMENTS = 0
+
+  constructor(options) {
+    super();
+
+    let dbOptions = util.defaults({
+      name: DB_NAME,
+      backupFlag: SqlStorage.BACKUP_NONE,
+      existingDatabase: false
+    }, options);
+
+
+    if(window.sqlitePlugin) {
+      let location = this._getBackupLocation(dbOptions);
+
+      this._db = window.sqlitePlugin.openDatabase(util.extend({
+        name: dbOptions.name,
+        location: location,
+        createFromLocation: dbOptions.existingDatabase ? 1 : 0
+      }, dbOptions));
+    } else {
+      console.warn('Storage: SQLite plugin not installed, falling back to WebSQL. Make sure to install cordova-sqlite-storage in production!');
+
+      this._db = window.openDatabase(dbOptions.name, '1.0', 'database', 5 * 1024 * 1024);
+    }
+    this._tryInit();
+  }
+
+  _getBackupLocation(dbFlag) {
+    switch(dbFlag) {
+      case SqlStorage.BACKUP_LOCAL:
+        return 2;
+      case SqlStorage.BACKUP_LIBRARY:
+        return 1;
+      case SqlStorage.BACKUP_DOCUMENTS:
+        return 0;
+      default:
+        throw Error('Invalid backup flag: ' + dbFlag);
+    }
+  }
+
+  // Initialize the DB with our required tables
+  _tryInit() {
+    this._db.transaction((tx) => {
+      tx.executeSql('CREATE TABLE IF NOT EXISTS kv (key text primary key, value text)', [], (tx, res) => {
+      }, (tx, err) => {
+        console.error('Storage: Unable to create initial storage tables', tx, err);
+      });
+    });
+  }
+
+  /**
+   * Perform an arbitrary SQL operation on the database. Use this method
+   * to have full control over the underlying database through SQL operations
+   * like SELECT, INSERT, and UPDATE.
+   *
+   * @param {string} query the query to run
+   * @return {Promise} that resolves or rejects with an object of the form { tx: Transaction, res: Result (or err)}
+   */
+  query(query) {
+    return new Promise((resolve, reject) => {
+      this._db.transaction((tx) => {
+        ts.executeSql(query, [], (tx, res) => {
+          resolve({
+            tx: tx,
+            res: res
+          });
+        }, (tx, err) => {
+          reject({
+            tx: tx,
+            err: err
+          });
+        })
+      });
+    })
+  }
+
+  /**
+   * Get the value in the database identified by the given key.
+   * @param {string} key the key
+   * @return {Promise} that resolves or rejects with an object of the form { tx: Transaction, res: Result (or err)}
+   */
+  get(key) {
+    return new Promise((resolve, reject) => {
+      try {
+
+        this._db.transaction(tx => {
+          tx.executeSql("select key, value from kv where key = ? limit 1", [key], (tx, res) => {
+            if(res.rows.length > 0) {
+              let item = res.rows.item(0);
+              resolve(item.value);
+            }
+            resolve(null);
+          }, (tx, err) => {
+            reject({
+              tx: tx,
+              err: err
+            });
+          })
+        }, err => {
+          reject(err);
+        });
+
+      } catch(e) {
+        reject(e);
+      }
+    });
+  }
+
+  /**
+  * Set the value in the database for the given key. Existing values will be overwritten.
+  * @param {string} key the key
+  * @param {string} value The value (as a string)
+  * @return {Promise} that resolves or rejects with an object of the form { tx: Transaction, res: Result (or err)}
+  */
+  set(key, value) {
+    return new Promise((resolve, reject) => {
+      try {
+        this._db.transaction(tx => {
+          tx.executeSql('insert or replace into kv(key, value) values (?, ?)', [key, value], (tx, res) => {
+            resolve();
+          }, (tx, err) => {
+            reject({
+              tx: tx,
+              err: err
+            });
+          })
+        }, err => {
+          reject(err);
+        });
+      } catch(e) {
+        reject(e);
+      }
+    });
+  }
+
+  /**
+  * Remove the value in the database for the given key.
+  * @param {string} key the key
+  * @param {string} value The value (as a string)
+  * @return {Promise} that resolves or rejects with an object of the form { tx: Transaction, res: Result (or err)}
+  */
+  remove(key) {
+    return new Promise((resolve, reject) => {
+      try {
+        this._db.transaction(tx => {
+          tx.executeSql('delete from kv where key = ?', [key], (tx, res) => {
+            resolve();
+          }, (tx, err) => {
+            reject({
+              tx: tx,
+              err: err
+            });
+          })
+        }, err => {
+          reject(err);
+        });
+      } catch(e) {
+        reject(e);
+      }
+    });
+
+  }
+}