Changing export pattern to have NoSqlProvider re-export all the providers

David de Regt · David de Regt · commit d7eefd4693b1 · 2016-01-05T18:23:32.000-08:00
diff --git a/dist/CordovaNativeSqliteProvider.d.ts b/dist/CordovaNativeSqliteProvider.d.ts
@@ -8,10 +8,9 @@
 import SyncTasks = require('synctasks');
 import NoSqlProvider = require('./NoSqlProvider');
 import SqlProviderBase = require('./SqlProviderBase');
-declare class CordovaNativeSqliteProvider extends SqlProviderBase.SqlProviderBase {
+export declare class CordovaNativeSqliteProvider extends SqlProviderBase.SqlProviderBase {
     private _db;
     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<SqlProviderBase.SqlTransaction>;
 }
-export = CordovaNativeSqliteProvider;
diff --git a/dist/CordovaNativeSqliteProvider.js b/dist/CordovaNativeSqliteProvider.js
@@ -60,6 +60,7 @@ var CordovaNativeSqliteProvider = (function (_super) {
     };
     return CordovaNativeSqliteProvider;
 })(SqlProviderBase.SqlProviderBase);
+exports.CordovaNativeSqliteProvider = CordovaNativeSqliteProvider;
 var CordovaNativeSqliteTransaction = (function (_super) {
     __extends(CordovaNativeSqliteTransaction, _super);
     function CordovaNativeSqliteTransaction() {
@@ -71,4 +72,3 @@ var CordovaNativeSqliteTransaction = (function (_super) {
     };
     return CordovaNativeSqliteTransaction;
 })(SqlProviderBase.SqliteSqlTransaction);
-module.exports = CordovaNativeSqliteProvider;
diff --git a/dist/InMemoryProvider.d.ts b/dist/InMemoryProvider.d.ts
@@ -1,10 +1,9 @@
 import SyncTasks = require('synctasks');
 import NoSqlProvider = require('./NoSqlProvider');
-declare class InMemoryProvider extends NoSqlProvider.DbProvider {
+export declare class InMemoryProvider extends NoSqlProvider.DbProvider {
     private _stores;
     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>;
     getStore(name: string): NoSqlProvider.DbStore;
 }
-export = InMemoryProvider;
diff --git a/dist/InMemoryProvider.js b/dist/InMemoryProvider.js
@@ -41,6 +41,7 @@ var InMemoryProvider = (function (_super) {
     };
     return InMemoryProvider;
 })(NoSqlProvider.DbProvider);
+exports.InMemoryProvider = InMemoryProvider;
 // Notes: Doesn't limit the stores it can fetch to those in the stores it was "created" with, nor does it handle read-only transactions
 var InMemoryTransaction = (function () {
     function InMemoryTransaction(prov) {
@@ -162,4 +163,3 @@ var InMemoryIndex = (function () {
     };
     return InMemoryIndex;
 })();
-module.exports = InMemoryProvider;
diff --git a/dist/IndexedDbProvider.d.ts b/dist/IndexedDbProvider.d.ts
@@ -1,6 +1,6 @@
 import SyncTasks = require('synctasks');
 import NoSqlProvider = require('./NoSqlProvider');
-declare class IndexedDbProvider extends NoSqlProvider.DbProvider {
+export declare class IndexedDbProvider extends NoSqlProvider.DbProvider {
     private _db;
     private _test;
     private _dbFactory;
@@ -11,4 +11,3 @@ declare class IndexedDbProvider extends NoSqlProvider.DbProvider {
     close(): SyncTasks.Promise<void>;
     openTransaction(storeNames: string | string[], writeNeeded: boolean): SyncTasks.Promise<NoSqlProvider.DbTransaction>;
 }
-export = IndexedDbProvider;
diff --git a/dist/IndexedDbProvider.js b/dist/IndexedDbProvider.js
@@ -219,6 +219,7 @@ var IndexedDbProvider = (function (_super) {
     };
     return IndexedDbProvider;
 })(NoSqlProvider.DbProvider);
+exports.IndexedDbProvider = IndexedDbProvider;
 // DbTransaction implementation for the IndexedDB DbProvider.
 var IndexedDbTransaction = (function () {
     function IndexedDbTransaction(trans, schema, storeNames, fakeComplicatedKeys) {
@@ -478,4 +479,3 @@ var IndexedDbIndex = (function () {
     };
     return IndexedDbIndex;
 })();
-module.exports = IndexedDbProvider;
diff --git a/dist/NoSqlProvider.d.ts b/dist/NoSqlProvider.d.ts
@@ -57,3 +57,9 @@ export declare abstract class DbProvider {
     getRange<T>(storeName: string, indexName: string, keyLowRange: any | any[], keyHighRange: any | any[], lowRangeExclusive?: boolean, highRangeExclusive?: boolean, reverse?: boolean, limit?: number, offset?: number): SyncTasks.Promise<T[]>;
 }
 export declare function openListOfProviders(providersToTry: DbProvider[], dbName: string, schema: DbSchema, wipeIfExists?: boolean, verbose?: boolean): SyncTasks.Promise<DbProvider>;
+export * from './CordovaNativeSqliteProvider';
+export * from './IndexedDbProvider';
+export * from './InMemoryProvider';
+export * from './NodeSqlite3MemoryDbProvider';
+export * from './ReactNativeSqliteProvider';
+export * from './WebSqlProvider';
diff --git a/dist/NodeSqlite3MemoryDbProvider.d.ts b/dist/NodeSqlite3MemoryDbProvider.d.ts
@@ -9,11 +9,10 @@
 import SyncTasks = require('synctasks');
 import NoSqlProvider = require('./NoSqlProvider');
 import SqlProviderBase = require('./SqlProviderBase');
-declare class NodeSqlite3MemoryDbProvider extends SqlProviderBase.SqlProviderBase {
+export declare class NodeSqlite3MemoryDbProvider extends SqlProviderBase.SqlProviderBase {
     private _db;
     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>;
     private _getTransaction();
 }
-export = NodeSqlite3MemoryDbProvider;
diff --git a/dist/NodeSqlite3MemoryDbProvider.js b/dist/NodeSqlite3MemoryDbProvider.js
@@ -12,7 +12,6 @@ var __extends = (this && this.__extends) || function (d, b) {
     d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
 };
 var SyncTasks = require('synctasks');
-var sqlite3 = require('sqlite3');
 var SqlProviderBase = require('./SqlProviderBase');
 var NodeSqlite3MemoryDbProvider = (function (_super) {
     __extends(NodeSqlite3MemoryDbProvider, _super);
@@ -21,6 +20,7 @@ var NodeSqlite3MemoryDbProvider = (function (_super) {
     }
     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:');
         return this._ourVersionChecker(wipeIfExists);
@@ -47,6 +47,7 @@ var NodeSqlite3MemoryDbProvider = (function (_super) {
     };
     return NodeSqlite3MemoryDbProvider;
 })(SqlProviderBase.SqlProviderBase);
+exports.NodeSqlite3MemoryDbProvider = NodeSqlite3MemoryDbProvider;
 var NodeSqlite3Transaction = (function (_super) {
     __extends(NodeSqlite3Transaction, _super);
     function NodeSqlite3Transaction(db, schema, verbose) {
@@ -97,4 +98,3 @@ var NodeSqlite3Transaction = (function (_super) {
     };
     return NodeSqlite3Transaction;
 })(SqlProviderBase.SqlTransaction);
-module.exports = NodeSqlite3MemoryDbProvider;
diff --git a/dist/ReactNativeSqliteProvider.d.ts b/dist/ReactNativeSqliteProvider.d.ts
@@ -8,10 +8,9 @@
 import SyncTasks = require('synctasks');
 import NoSqlProvider = require('./NoSqlProvider');
 import SqlProviderBase = require('./SqlProviderBase');
-declare class ReactNativeSqliteProvider extends SqlProviderBase.SqlProviderBase {
+export declare class ReactNativeSqliteProvider extends SqlProviderBase.SqlProviderBase {
     private _db;
     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>;
 }
-export = ReactNativeSqliteProvider;
diff --git a/dist/ReactNativeSqliteProvider.js b/dist/ReactNativeSqliteProvider.js
@@ -56,6 +56,7 @@ var ReactNativeSqliteProvider = (function (_super) {
     };
     return ReactNativeSqliteProvider;
 })(SqlProviderBase.SqlProviderBase);
+exports.ReactNativeSqliteProvider = ReactNativeSqliteProvider;
 var ReactNativeSqliteTransaction = (function (_super) {
     __extends(ReactNativeSqliteTransaction, _super);
     function ReactNativeSqliteTransaction(db, schema, verbose) {
@@ -98,4 +99,3 @@ var ReactNativeSqliteTransaction = (function (_super) {
     };
     return ReactNativeSqliteTransaction;
 })(SqlProviderBase.SqlTransaction);
-module.exports = ReactNativeSqliteProvider;
diff --git a/dist/WebSqlProvider.d.ts b/dist/WebSqlProvider.d.ts
@@ -8,10 +8,9 @@
 import SyncTasks = require('synctasks');
 import NoSqlProvider = require('./NoSqlProvider');
 import SqlProviderBase = require('./SqlProviderBase');
-declare class WebSqlProvider extends SqlProviderBase.SqlProviderBase {
+export declare class WebSqlProvider extends SqlProviderBase.SqlProviderBase {
     private _db;
     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<SqlProviderBase.SqlTransaction>;
 }
-export = WebSqlProvider;
diff --git a/dist/WebSqlProvider.js b/dist/WebSqlProvider.js
@@ -70,4 +70,4 @@ var WebSqlProvider = (function (_super) {
     };
     return WebSqlProvider;
 })(SqlProviderBase.SqlProviderBase);
-module.exports = WebSqlProvider;
+exports.WebSqlProvider = WebSqlProvider;
diff --git a/dist/nosqlprovider.js b/dist/nosqlprovider.js
@@ -7,6 +7,9 @@
  * numerous different backend store types, invisible to the consumer.  The
  * usage semantics are very similar to IndexedDB.
  */
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
 var SyncTasks = require('synctasks');
 // Abstract base type for a database provider.  Has accessors for opening transactions and one-off accesor helpers.
 // Note: this is a different concept than a DbStore or DbIndex, although it provides a similar (or identical) interface.
@@ -102,3 +105,9 @@ function openListOfProviders(providersToTry, dbName, schema, wipeIfExists, verbo
     return task.promise();
 }
 exports.openListOfProviders = openListOfProviders;
+__export(require('./CordovaNativeSqliteProvider'));
+__export(require('./IndexedDbProvider'));
+__export(require('./InMemoryProvider'));
+__export(require('./NodeSqlite3MemoryDbProvider'));
+__export(require('./ReactNativeSqliteProvider'));
+__export(require('./WebSqlProvider'));
diff --git a/dist/tests/NoSqlProviderTests.js b/dist/tests/NoSqlProviderTests.js
@@ -5,23 +5,20 @@ var sqlite3 = require('sqlite3');
 var indexeddbjs = require('indexeddb-js');
 var NoSqlProvider = require('../NoSqlProvider');
 var NoSqlProviderUtils = require('../NoSqlProviderUtils');
-var NodeSqlite3MemoryDbProvider = require('../NodeSqlite3MemoryDbProvider');
-var IndexedDbProvider = require('../IndexedDbProvider');
-var InMemoryProvider = require('../InMemoryProvider');
 function openProvider(providerName, schema) {
     var provider = null;
     if (providerName === 'sqlite3test') {
-        provider = new NodeSqlite3MemoryDbProvider();
+        provider = new NoSqlProvider.NodeSqlite3MemoryDbProvider();
     }
     else if (providerName === 'indexeddbtest') {
         var engine = new sqlite3.Database(':memory:');
         var scope = indexeddbjs.makeScope('sqlite3', engine);
         global['IDBKeyRange'] = scope.IDBKeyRange;
         var idbFactory = scope.indexedDB;
-        provider = new IndexedDbProvider(idbFactory, false);
+        provider = new NoSqlProvider.IndexedDbProvider(idbFactory, false);
     }
     else if (providerName === 'memory') {
-        provider = new InMemoryProvider();
+        provider = new NoSqlProvider.InMemoryProvider();
     }
     return NoSqlProvider.openListOfProviders([provider], 'test', schema, true);
 }
diff --git a/src/CordovaNativeSqliteProvider.ts b/src/CordovaNativeSqliteProvider.ts
@@ -12,7 +12,7 @@ import NoSqlProvider = require('./NoSqlProvider');
 import SqlProviderBase = require('./SqlProviderBase');
 
 // The DbProvider implementation for Native Sqlite on cordova
-class CordovaNativeSqliteProvider extends SqlProviderBase.SqlProviderBase {
+export class CordovaNativeSqliteProvider extends SqlProviderBase.SqlProviderBase {
     private _db: SqliteDatabase;
     open(dbName: string, schema: NoSqlProvider.DbSchema, wipeIfExists: boolean, verbose: boolean): SyncTasks.Promise<void> {
         super.open(dbName, schema, wipeIfExists, verbose);
@@ -69,5 +69,3 @@ class CordovaNativeSqliteTransaction extends SqlProviderBase.SqliteSqlTransactio
         return true;
     }
 }
-
-export = CordovaNativeSqliteProvider;
diff --git a/src/InMemoryProvider.ts b/src/InMemoryProvider.ts
@@ -13,7 +13,7 @@ import NoSqlProvider = require('./NoSqlProvider');
 import NoSqlProviderUtils = require('./NoSqlProviderUtils');
 
 // Very simple in-memory dbprovider for handling IE inprivate windows (and unit tests, maybe?)
-class InMemoryProvider extends NoSqlProvider.DbProvider {
+export class InMemoryProvider extends NoSqlProvider.DbProvider {
     private _stores: { [storeName: string]: InMemoryStore } = {};
 
     open(dbName: string, schema: NoSqlProvider.DbSchema, wipeIfExists: boolean, verbose: boolean): SyncTasks.Promise<void> {
@@ -183,5 +183,3 @@ class InMemoryIndex implements NoSqlProvider.DbIndex {
         return SyncTasks.Resolved(_.flatten(results));
     }
 }
- 
-export = InMemoryProvider;
diff --git a/src/IndexedDbProvider.ts b/src/IndexedDbProvider.ts
@@ -15,7 +15,7 @@ import NoSqlProviderUtils = require('./NoSqlProviderUtils');
 // The DbProvider implementation for IndexedDB.  This one is fairly straightforward since the library's access patterns pretty
 // closely mirror IndexedDB's.  We mostly do a lot of wrapping of the APIs into JQuery promises and have some fancy footwork to
 // do semi-automatic schema upgrades.
-class IndexedDbProvider extends NoSqlProvider.DbProvider {
+export class IndexedDbProvider extends NoSqlProvider.DbProvider {
     private _db: IDBDatabase;
     private _test: boolean;
     private _dbFactory: IDBFactory;
@@ -545,5 +545,3 @@ class IndexedDbIndex implements NoSqlProvider.DbIndex {
         return deferred.promise();
     }
 }
-
-export = IndexedDbProvider;
diff --git a/src/NoSqlProvider.ts b/src/NoSqlProvider.ts
@@ -177,3 +177,10 @@ export function openListOfProviders(providersToTry: DbProvider[], dbName: string
 
     return task.promise();
 }
+
+export * from './CordovaNativeSqliteProvider';
+export * from './IndexedDbProvider';
+export * from './InMemoryProvider';
+export * from './NodeSqlite3MemoryDbProvider';
+export * from './ReactNativeSqliteProvider';
+export * from './WebSqlProvider';
diff --git a/src/NodeSqlite3MemoryDbProvider.ts b/src/NodeSqlite3MemoryDbProvider.ts
@@ -9,16 +9,16 @@
 
 import SyncTasks = require('synctasks');
 
-import sqlite3 = require('sqlite3');
-
 import NoSqlProvider = require('./NoSqlProvider');
 import SqlProviderBase = require('./SqlProviderBase');
 
-class NodeSqlite3MemoryDbProvider extends SqlProviderBase.SqlProviderBase {
+export class NodeSqlite3MemoryDbProvider extends SqlProviderBase.SqlProviderBase {
     private _db: any;
     open(dbName: string, schema: NoSqlProvider.DbSchema, wipeIfExists: boolean, verbose: boolean): SyncTasks.Promise<void> {
         super.open(dbName, schema, wipeIfExists, verbose);
 
+        var sqlite3 = require('sqlite3');
+
         sqlite3.verbose();
 
         this._db = new sqlite3.Database(':memory:');
@@ -107,5 +107,3 @@ class NodeSqlite3Transaction extends SqlProviderBase.SqlTransaction {
         return deferred.promise();
     }
 }
-
-export = NodeSqlite3MemoryDbProvider;
diff --git a/src/ReactNativeSqliteProvider.ts b/src/ReactNativeSqliteProvider.ts
@@ -17,7 +17,7 @@ interface ReactNativeSqliteDatabase {
     close(callback: (error: any) => void): void;
 }
 
-class ReactNativeSqliteProvider extends SqlProviderBase.SqlProviderBase {
+export class ReactNativeSqliteProvider extends SqlProviderBase.SqlProviderBase {
     private _db: ReactNativeSqliteDatabase;
 
     open(dbName: string, schema: NoSqlProvider.DbSchema, wipeIfExists: boolean, verbose: boolean): SyncTasks.Promise<void> {
@@ -116,5 +116,3 @@ class ReactNativeSqliteTransaction extends SqlProviderBase.SqlTransaction {
         return deferred.promise();
     }
 }
-
-export = ReactNativeSqliteProvider;
diff --git a/src/WebSqlProvider.ts b/src/WebSqlProvider.ts
@@ -14,7 +14,7 @@ import SqlProviderBase = require('./SqlProviderBase');
 // The DbProvider implementation for WebSQL.  This provider does a bunch of awkward stuff to pretend that a relational SQL store
 // is actually a NoSQL store.  We store the raw object as a JSON.encoded string in the nsp_data column, and have an nsp_pk column
 // for the primary keypath value, then nsp_i_[index name] columns for each of the indexes.
-class WebSqlProvider extends SqlProviderBase.SqlProviderBase {
+export class WebSqlProvider extends SqlProviderBase.SqlProviderBase {
     private _db: Database;
 
     open(dbName: string, schema: NoSqlProvider.DbSchema, wipeIfExists: boolean, verbose: boolean): SyncTasks.Promise<void> {
@@ -72,5 +72,3 @@ class WebSqlProvider extends SqlProviderBase.SqlProviderBase {
         return deferred.promise();
     }
 }
-
-export = WebSqlProvider;
diff --git a/src/tests/NoSqlProviderTests.ts b/src/tests/NoSqlProviderTests.ts
@@ -7,23 +7,22 @@ import indexeddbjs = require('indexeddb-js');
 
 import NoSqlProvider = require('../NoSqlProvider');
 import NoSqlProviderUtils = require('../NoSqlProviderUtils');
-import NodeSqlite3MemoryDbProvider = require('../NodeSqlite3MemoryDbProvider');
 import IndexedDbProvider = require('../IndexedDbProvider');
 import InMemoryProvider = require('../InMemoryProvider');
 
 function openProvider(providerName: string, schema: NoSqlProvider.DbSchema) {
     let provider: NoSqlProvider.DbProvider = null;
     if (providerName === 'sqlite3test') {
-        provider = new NodeSqlite3MemoryDbProvider();
+        provider = new NoSqlProvider.NodeSqlite3MemoryDbProvider();
     } else if (providerName === 'indexeddbtest') {
         const engine = new sqlite3.Database(':memory:');
         const scope = indexeddbjs.makeScope('sqlite3', engine);
         global['IDBKeyRange'] = scope.IDBKeyRange;
 
         const idbFactory = scope.indexedDB;
-        provider = new IndexedDbProvider(idbFactory, false);
+        provider = new NoSqlProvider.IndexedDbProvider(idbFactory, false);
     } else if (providerName === 'memory') {
-        provider = new InMemoryProvider();
+        provider = new NoSqlProvider.InMemoryProvider();
     }
     return NoSqlProvider.openListOfProviders([provider], 'test', schema, true);
 }
