Forced NodeSqlite3MemoryDbProvider to take a copy of the sqlite3 module to use, and same thing for the ReactNativeSqliteProvider. This fixes browserify issues with including all the modules for a project that doesn't need those providers' external module implementations.

Author: David de Regt

dist/NodeSqlite3MemoryDbProvider.d.ts

@@ -10,7 +10,9 @@ import SyncTasks = require('synctasks');
 import NoSqlProvider = require('./NoSqlProvider');
 import SqlProviderBase = require('./SqlProviderBase');
 export declare class NodeSqlite3MemoryDbProvider extends SqlProviderBase.SqlProviderBase {
+    private _sqlite3;
     private _db;
+    constructor(sqlite3: any);
     open(dbName: string, schema: NoSqlProvider.DbSchema, wipeIfExists: boolean, verbose: boolean): SyncTasks.Promise<void>;
     openTransaction(storeNames: string | string[], writeNeeded: boolean): SyncTasks.Promise<NoSqlProvider.DbTransaction>;
     close(): SyncTasks.Promise<void>;

dist/NodeSqlite3MemoryDbProvider.js

@@ -15,14 +15,17 @@ var SyncTasks = require('synctasks');
 var SqlProviderBase = require('./SqlProviderBase');
 var NodeSqlite3MemoryDbProvider = (function (_super) {
     __extends(NodeSqlite3MemoryDbProvider, _super);
-    function NodeSqlite3MemoryDbProvider() {
-        _super.apply(this, arguments);
+    function NodeSqlite3MemoryDbProvider(sqlite3) {
+        _super.call(this);
+        this._sqlite3 = sqlite3;
     }
     NodeSqlite3MemoryDbProvider.prototype.open = function (dbName, schema, wipeIfExists, verbose) {
         _super.prototype.open.call(this, dbName, schema, wipeIfExists, verbose);
-        var sqlite3 = require('sqlite3');
-        sqlite3.verbose();
-        this._db = new sqlite3.Database(':memory:');
+        if (!this._sqlite3) {
+            return SyncTasks.Rejected('No support for react native sqlite in this environment');
+        }
+        this._sqlite3.verbose();
+        this._db = new this._sqlite3.Database(':memory:');
         return this._ourVersionChecker(wipeIfExists);
     };
     NodeSqlite3MemoryDbProvider.prototype.openTransaction = function (storeNames, writeNeeded) {

dist/ReactNativeSqliteProvider.d.ts

@@ -9,7 +9,9 @@ import SyncTasks = require('synctasks');
 import NoSqlProvider = require('./NoSqlProvider');
 import SqlProviderBase = require('./SqlProviderBase');
 export declare class ReactNativeSqliteProvider extends SqlProviderBase.SqlProviderBase {
+    private _reactNativeSqlite;
     private _db;
+    constructor(reactNativeSqlite: any);
     open(dbName: string, schema: NoSqlProvider.DbSchema, wipeIfExists: boolean, verbose: boolean): SyncTasks.Promise<void>;
     close(): SyncTasks.Promise<void>;
     openTransaction(storeNames: string | string[], writeNeeded: boolean): SyncTasks.Promise<NoSqlProvider.DbTransaction>;

dist/ReactNativeSqliteProvider.js

@@ -14,18 +14,18 @@ var SyncTasks = require('synctasks');
 var SqlProviderBase = require('./SqlProviderBase');
 var ReactNativeSqliteProvider = (function (_super) {
     __extends(ReactNativeSqliteProvider, _super);
-    function ReactNativeSqliteProvider() {
-        _super.apply(this, arguments);
+    function ReactNativeSqliteProvider(reactNativeSqlite) {
+        _super.call(this);
+        this._reactNativeSqlite = reactNativeSqlite;
     }
     ReactNativeSqliteProvider.prototype.open = function (dbName, schema, wipeIfExists, verbose) {
         var _this = this;
         _super.prototype.open.call(this, dbName, schema, wipeIfExists, verbose);
-        var sqlite = require('react-native-sqlite');
-        if (!sqlite || !sqlite.open) {
+        if (!this._reactNativeSqlite || !this._reactNativeSqlite.open) {
             return SyncTasks.Rejected('No support for react native sqlite in this environment');
         }
         var deferred = SyncTasks.Defer();
-        sqlite.open(dbName + '.sqlite', function (error, database) {
+        this._reactNativeSqlite.open(dbName + '.sqlite', function (error, database) {
             if (error) {
                 deferred.reject('Error opening database: ' + error);
                 return;

dist/tests/NoSqlProviderTests.js

@@ -8,7 +8,7 @@ var NoSqlProviderUtils = require('../NoSqlProviderUtils');
 function openProvider(providerName, schema) {
     var provider = null;
     if (providerName === 'sqlite3test') {
-        provider = new NoSqlProvider.NodeSqlite3MemoryDbProvider();
+        provider = new NoSqlProvider.NodeSqlite3MemoryDbProvider(sqlite3);
     }
     else if (providerName === 'indexeddbtest') {
         var engine = new sqlite3.Database(':memory:');

src/NodeSqlite3MemoryDbProvider.ts

@@ -13,15 +13,25 @@ import NoSqlProvider = require('./NoSqlProvider');
 import SqlProviderBase = require('./SqlProviderBase');
 
 export class NodeSqlite3MemoryDbProvider extends SqlProviderBase.SqlProviderBase {
+    private _sqlite3: any;
     private _db: any;
+
+    constructor(sqlite3: any) {
+        super();
+
+        this._sqlite3 = sqlite3;
+    }
+
     open(dbName: string, schema: NoSqlProvider.DbSchema, wipeIfExists: boolean, verbose: boolean): SyncTasks.Promise<void> {
         super.open(dbName, schema, wipeIfExists, verbose);
 
-        var sqlite3 = require('sqlite3');
+        if (!this._sqlite3) {
+            return SyncTasks.Rejected<void>('No support for react native sqlite in this environment');
+        }
 
-        sqlite3.verbose();
+        this._sqlite3.verbose();
 
-        this._db = new sqlite3.Database(':memory:');
+        this._db = new this._sqlite3.Database(':memory:');
 
         return this._ourVersionChecker(wipeIfExists);
     }

src/ReactNativeSqliteProvider.ts

@@ -18,19 +18,25 @@ interface ReactNativeSqliteDatabase {
 }
 
 export class ReactNativeSqliteProvider extends SqlProviderBase.SqlProviderBase {
+    private _reactNativeSqlite: any;
     private _db: ReactNativeSqliteDatabase;
 
+    constructor(reactNativeSqlite: any) {
+        super();
+
+        this._reactNativeSqlite = reactNativeSqlite;
+    }
+
     open(dbName: string, schema: NoSqlProvider.DbSchema, wipeIfExists: boolean, verbose: boolean): SyncTasks.Promise<void> {
         super.open(dbName, schema, wipeIfExists, verbose);
 
-        var sqlite = require('react-native-sqlite');
-        if (!sqlite || !sqlite.open) {
+        if (!this._reactNativeSqlite || !this._reactNativeSqlite.open) {
             return SyncTasks.Rejected<void>('No support for react native sqlite in this environment');
         }
 
         let deferred = SyncTasks.Defer<void>();
 
-        sqlite.open(dbName + '.sqlite', (error, database) => {
+        this._reactNativeSqlite.open(dbName + '.sqlite', (error, database) => {
             if (error) {
                 deferred.reject('Error opening database: ' + error);
                 return;

src/tests/NoSqlProviderTests.ts

@@ -13,7 +13,7 @@ import InMemoryProvider = require('../InMemoryProvider');
 function openProvider(providerName: string, schema: NoSqlProvider.DbSchema) {
     let provider: NoSqlProvider.DbProvider = null;
     if (providerName === 'sqlite3test') {
-        provider = new NoSqlProvider.NodeSqlite3MemoryDbProvider();
+        provider = new NoSqlProvider.NodeSqlite3MemoryDbProvider(sqlite3);
     } else if (providerName === 'indexeddbtest') {
         const engine = new sqlite3.Database(':memory:');
         const scope = indexeddbjs.makeScope('sqlite3', engine);