yeet

node_modules/@expo/websql/lib/browser.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = global.openDatabase;

node_modules/@expo/websql/lib/custom.js

@@ -0,0 +1,41 @@
+'use strict';
+
+var immediate = require('immediate');
+var argsarray = require('argsarray');
+
+var WebSQLDatabase = require('./websql/WebSQLDatabase');
+
+function customOpenDatabase(SQLiteDatabase) {
+
+  function createDb(dbName, dbVersion) {
+    var sqliteDatabase = new SQLiteDatabase(dbName);
+    return new WebSQLDatabase(dbVersion, sqliteDatabase);
+  }
+
+  function openDatabase(args) {
+
+    if (args.length < 4) {
+      throw new Error('Failed to execute \'openDatabase\': ' +
+        '4 arguments required, but only ' + args.length + ' present');
+    }
+
+    var dbName = args[0];
+    var dbVersion = args[1];
+    // db description and size are ignored
+    var callback = args[4];
+
+    var db = createDb(dbName, dbVersion);
+
+    if (typeof callback === 'function') {
+      immediate(function () {
+        callback(db);
+      });
+    }
+
+    return db;
+  }
+
+  return argsarray(openDatabase);
+}
+
+module.exports = customOpenDatabase;

node_modules/@expo/websql/lib/index.js

@@ -0,0 +1,6 @@
+'use strict';
+
+var SQLiteDatabase = require('./sqlite/SQLiteDatabase');
+var customOpenDatabase = require('./custom');
+
+module.exports = customOpenDatabase(SQLiteDatabase);

node_modules/@expo/websql/lib/sqlite/SQLiteDatabase.js

@@ -0,0 +1,88 @@
+'use strict';
+
+var sqlite3 = require('sqlite3');
+var SQLiteResult = require('./SQLiteResult');
+
+var READ_ONLY_ERROR = new Error(
+  'could not prepare statement (23 not authorized)');
+
+function SQLiteDatabase(name) {
+  this._db = new sqlite3.Database(name);
+}
+
+function runSelect(db, sql, args, cb) {
+  db.all(sql, args, function (err, rows) {
+    if (err) {
+      return cb(new SQLiteResult(err));
+    }
+    var insertId = void 0;
+    var rowsAffected = 0;
+    var resultSet = new SQLiteResult(null, insertId, rowsAffected, rows);
+    cb(resultSet);
+  });
+}
+
+function runNonSelect(db, sql, args, cb) {
+  db.run(sql, args, function (err) {
+    if (err) {
+      return cb(new SQLiteResult(err));
+    }
+    /* jshint validthis:true */
+    var executionResult = this;
+    var insertId = executionResult.lastID;
+    var rowsAffected = executionResult.changes;
+    var rows = [];
+    var resultSet = new SQLiteResult(null, insertId, rowsAffected, rows);
+    cb(resultSet);
+  });
+}
+
+SQLiteDatabase.prototype.exec = function exec(queries, readOnly, callback) {
+
+  var db = this._db;
+  var len = queries.length;
+  var results = new Array(len);
+
+  var i = 0;
+
+  function checkDone() {
+    if (++i === len) {
+      callback(null, results);
+    } else {
+      doNext();
+    }
+  }
+
+  function onQueryComplete(i) {
+    return function (res) {
+      results[i] = res;
+      checkDone();
+    };
+  }
+
+  function doNext() {
+    var query = queries[i];
+    var sql = query.sql;
+    var args = query.args;
+
+    // TODO: It seems like the node-sqlite3 API either allows:
+    // 1) all(), which returns results but not rowsAffected or lastID
+    // 2) run(), which doesn't return results, but returns rowsAffected and lastID
+    // So we try to sniff whether it's a SELECT query or not.
+    // This is inherently error-prone, although it will probably work in the 99%
+    // case.
+    var isSelect = /^\s*SELECT\b/i.test(sql);
+
+    if (readOnly && !isSelect) {
+      onQueryComplete(i)(new SQLiteResult(READ_ONLY_ERROR));
+    } else if (isSelect) {
+      runSelect(db, sql, args, onQueryComplete(i));
+    } else {
+      runNonSelect(db, sql, args, onQueryComplete(i));
+    }
+  }
+
+  doNext();
+};
+
+module.exports = SQLiteDatabase;

node_modules/@expo/websql/lib/sqlite/SQLiteResult.js

@@ -0,0 +1,10 @@
+'use strict';
+
+function SQLiteResult(error, insertId, rowsAffected, rows) {
+  this.error = error;
+  this.insertId = insertId;
+  this.rowsAffected = rowsAffected;
+  this.rows = rows;
+}
+
+module.exports = SQLiteResult;

node_modules/@expo/websql/lib/websql/WebSQLDatabase.js

@@ -0,0 +1,102 @@
+'use strict';
+
+var Queue = require('tiny-queue');
+var immediate = require('immediate');
+var noop = require('noop-fn');
+
+var WebSQLTransaction = require('./WebSQLTransaction');
+
+var ROLLBACK = [
+  {sql: 'ROLLBACK;', args: []}
+];
+
+var COMMIT = [
+  {sql: 'END;', args: []}
+];
+
+// v8 likes predictable objects
+function TransactionTask(readOnly, txnCallback, errorCallback, successCallback) {
+  this.readOnly = readOnly;
+  this.txnCallback = txnCallback;
+  this.errorCallback = errorCallback;
+  this.successCallback = successCallback;
+}
+
+function WebSQLDatabase(dbVersion, db) {
+  this.version = dbVersion;
+  this._db = db;
+  this._txnQueue = new Queue();
+  this._running = false;
+  this._currentTask = null;
+}
+
+WebSQLDatabase.prototype._onTransactionComplete = function(err) {
+  var self = this;
+
+  function done() {
+    if (err) {
+      self._currentTask.errorCallback(err);
+    } else {
+      self._currentTask.successCallback();
+    }
+    self._running = false;
+    self._currentTask = null;
+    self._runNextTransaction();
+  }
+
+  if (self._currentTask.readOnly) {
+    done(); // read-only doesn't require a transaction
+  } else if (err) {
+    self._db.exec(ROLLBACK, false, done);
+  } else {
+    self._db.exec(COMMIT, false, done);
+  }
+};
+
+WebSQLDatabase.prototype._runTransaction = function () {
+  var self = this;
+  var txn = new WebSQLTransaction(self);
+
+  immediate(function () {
+    self._currentTask.txnCallback(txn);
+    txn._checkDone();
+  });
+};
+
+WebSQLDatabase.prototype._runNextTransaction = function() {
+  if (this._running) {
+    return;
+  }
+  var task = this._txnQueue.shift();
+
+  if (!task) {
+    return;
+  }
+
+  this._currentTask = task;
+  this._running = true;
+  this._runTransaction();
+};
+
+WebSQLDatabase.prototype._createTransaction = function(
+    readOnly, txnCallback, errorCallback, successCallback) {
+  errorCallback = errorCallback || noop;
+  successCallback = successCallback || noop;
+
+  if (typeof txnCallback !== 'function') {
+    throw new Error('The callback provided as parameter 1 is not a function.');
+  }
+
+  this._txnQueue.push(new TransactionTask(readOnly, txnCallback, errorCallback, successCallback));
+  this._runNextTransaction();
+};
+
+WebSQLDatabase.prototype.transaction = function (txnCallback, errorCallback, successCallback) {
+  this._createTransaction(false, txnCallback, errorCallback, successCallback);
+};
+
+WebSQLDatabase.prototype.readTransaction = function (txnCallback, errorCallback, successCallback) {
+  this._createTransaction(true, txnCallback, errorCallback, successCallback);
+};
+
+module.exports = WebSQLDatabase;

node_modules/@expo/websql/lib/websql/WebSQLResultSet.js

@@ -0,0 +1,18 @@
+'use strict';
+
+function WebSQLRows(array) {
+  this._array = array;
+  this.length = array.length;
+}
+
+WebSQLRows.prototype.item = function (i) {
+  return this._array[i];
+};
+
+function WebSQLResultSet(insertId, rowsAffected, rows) {
+  this.insertId = insertId;
+  this.rowsAffected = rowsAffected;
+  this.rows = new WebSQLRows(rows);
+}
+
+module.exports = WebSQLResultSet;

node_modules/@expo/websql/lib/websql/WebSQLTransaction.js

@@ -0,0 +1,132 @@
+'use strict';
+
+var noop = require('noop-fn');
+var Queue = require('tiny-queue');
+var immediate = require('immediate');
+var WebSQLResultSet = require('./WebSQLResultSet');
+
+function errorUnhandled() {
+  return true; // a non-truthy return indicates error was handled
+}
+
+// WebSQL has some bizarre behavior regarding insertId/rowsAffected. To try
+// to match the observed behavior of Chrome/Safari as much as possible, we
+// sniff the SQL message to try to massage the returned insertId/rowsAffected.
+// This helps us pass the tests, although it's error-prone and should
+// probably be revised.
+function massageSQLResult(sql, insertId, rowsAffected, rows) {
+  if (/^\s*UPDATE\b/i.test(sql)) {
+    // insertId is always undefined for "UPDATE" statements
+    insertId = void 0;
+  } else if (/^\s*CREATE\s+TABLE\b/i.test(sql)) {
+    // WebSQL always returns an insertId of 0 for "CREATE TABLE" statements
+    insertId = 0;
+    rowsAffected = 0;
+  } else if (/^\s*DROP\s+TABLE\b/i.test(sql)) {
+    // WebSQL always returns insertId=undefined and rowsAffected=0
+    // for "DROP TABLE" statements. Go figure.
+    insertId = void 0;
+    rowsAffected = 0;
+  } else if (!/^\s*INSERT\b/i.test(sql)) {
+    // for all non-inserts (deletes, etc.) insertId is always undefined
+    // ¯\_(ツ)_/¯
+    insertId = void 0;
+  }
+  return new WebSQLResultSet(insertId, rowsAffected, rows);
+}
+
+function SQLTask(sql, args, sqlCallback, sqlErrorCallback) {
+  this.sql = sql;
+  this.args = args;
+  this.sqlCallback = sqlCallback;
+  this.sqlErrorCallback = sqlErrorCallback;
+}
+
+function runBatch(self, batch) {
+
+  function onDone() {
+    self._running = false;
+    runAllSql(self);
+  }
+
+  var readOnly = self._websqlDatabase._currentTask.readOnly;
+
+  self._websqlDatabase._db.exec(batch, readOnly, function (err, results) {
+    /* istanbul ignore next */
+    if (err) {
+      self._error = err;
+      return onDone();
+    }
+    for (var i = 0; i < results.length; i++) {
+      var res = results[i];
+      var batchTask = batch[i];
+      if (res.error) {
+        if (batchTask.sqlErrorCallback(self, res.error)) {
+          // user didn't handle the error
+          self._error = res.error;
+          return onDone();
+        }
+      } else {
+        batchTask.sqlCallback(self, massageSQLResult(
+          batch[i].sql, res.insertId, res.rowsAffected, res.rows));
+      }
+    }
+    onDone();
+  });
+}
+
+function runAllSql(self) {
+  if (self._running || self._complete) {
+    return;
+  }
+  if (self._error || !self._sqlQueue.length) {
+    self._complete = true;
+    return self._websqlDatabase._onTransactionComplete(self._error);
+  }
+  self._running = true;
+  var batch = [];
+  var task;
+  while ((task = self._sqlQueue.shift())) {
+    batch.push(task);
+  }
+  runBatch(self, batch);
+}
+
+function executeSql(self, sql, args, sqlCallback, sqlErrorCallback) {
+  self._sqlQueue.push(new SQLTask(sql, args, sqlCallback, sqlErrorCallback));
+  if (self._runningTimeout) {
+    return;
+  }
+  self._runningTimeout = true;
+  immediate(function () {
+    self._runningTimeout = false;
+    runAllSql(self);
+  });
+}
+
+function WebSQLTransaction(websqlDatabase) {
+  this._websqlDatabase = websqlDatabase;
+  this._error = null;
+  this._complete = false;
+  this._runningTimeout = false;
+  this._sqlQueue = new Queue();
+  if (!websqlDatabase._currentTask.readOnly) {
+    // Since we serialize all access to the database, there is no need to
+    // run read-only tasks in a transaction. This is a perf boost.
+    this._sqlQueue.push(new SQLTask('BEGIN;', [], noop, noop));
+  }
+}
+
+WebSQLTransaction.prototype.executeSql = function (sql, args, sqlCallback, sqlErrorCallback) {
+  args = Array.isArray(args) ? args : [];
+  sqlCallback = typeof sqlCallback === 'function' ? sqlCallback : noop;
+  sqlErrorCallback = typeof sqlErrorCallback === 'function' ? sqlErrorCallback : errorUnhandled;
+
+  executeSql(this, sql, args, sqlCallback, sqlErrorCallback);
+};
+
+WebSQLTransaction.prototype._checkDone = function () {
+  runAllSql(this);
+};
+
+module.exports = WebSQLTransaction;