Refactored out the interfaces from NoSqlProvider into NoSqlProviderInterfaces to avoid the circular dependency I stupidly introduced

Author: David de Regt

dist/CordovaNativeSqliteProvider.d.ts

@@ -6,7 +6,7 @@
  * NoSqlProvider provider setup for cordova-native-sqlite, a cordova plugin backed by sqlite3.
  */
 import SyncTasks = require('synctasks');
-import NoSqlProvider = require('./NoSqlProvider');
+import NoSqlProvider = require('./NoSqlProviderInterfaces');
 import SqlProviderBase = require('./SqlProviderBase');
 export declare class CordovaNativeSqliteProvider extends SqlProviderBase.SqlProviderBase {
     private _db;

dist/InMemoryProvider.d.ts

@@ -1,5 +1,5 @@
 import SyncTasks = require('synctasks');
-import NoSqlProvider = require('./NoSqlProvider');
+import NoSqlProvider = require('./NoSqlProviderInterfaces');
 export declare class InMemoryProvider extends NoSqlProvider.DbProvider {
     private _stores;
     open(dbName: string, schema: NoSqlProvider.DbSchema, wipeIfExists: boolean, verbose: boolean): SyncTasks.Promise<void>;

dist/InMemoryProvider.js

@@ -12,7 +12,7 @@ var __extends = (this && this.__extends) || function (d, b) {
 };
 var _ = require('lodash');
 var SyncTasks = require('synctasks');
-var NoSqlProvider = require('./NoSqlProvider');
+var NoSqlProvider = require('./NoSqlProviderInterfaces');
 var NoSqlProviderUtils = require('./NoSqlProviderUtils');
 // Very simple in-memory dbprovider for handling IE inprivate windows (and unit tests, maybe?)
 var InMemoryProvider = (function (_super) {

dist/IndexedDbProvider.d.ts

@@ -1,5 +1,5 @@
 import SyncTasks = require('synctasks');
-import NoSqlProvider = require('./NoSqlProvider');
+import NoSqlProvider = require('./NoSqlProviderInterfaces');
 export declare class IndexedDbProvider extends NoSqlProvider.DbProvider {
     private _db;
     private _test;

dist/IndexedDbProvider.js

@@ -12,7 +12,7 @@ var __extends = (this && this.__extends) || function (d, b) {
 };
 var _ = require('lodash');
 var SyncTasks = require('synctasks');
-var NoSqlProvider = require('./NoSqlProvider');
+var NoSqlProvider = require('./NoSqlProviderInterfaces');
 var 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

dist/NoSqlProvider.d.ts

@@ -1,62 +1,13 @@
 /**
  * NoSqlProvider.ts
  * Author: David de Regt
- * Copyright: Microsoft 2015
+ * Copyright: Microsoft 2016
  *
  * Low-level wrapper to expose a nosql-like database which can be backed by
  * numerous different backend store types, invisible to the consumer.  The
  * usage semantics are very similar to IndexedDB.
  */
-import SyncTasks = require('synctasks');
-export interface IndexSchema {
-    name: string;
-    keyPath: string | string[];
-    unique?: boolean;
-    multiEntry?: boolean;
-}
-export interface StoreSchema {
-    name: string;
-    indexes?: IndexSchema[];
-    primaryKeyPath: string | string[];
-}
-export interface DbSchema {
-    version: number;
-    lastUsableVersion?: number;
-    stores: StoreSchema[];
-}
-export interface DbIndex {
-    getAll<T>(reverse?: boolean, limit?: number, offset?: number): SyncTasks.Promise<T[]>;
-    getOnly<T>(key: any | any[], reverse?: boolean, limit?: number, offset?: number): SyncTasks.Promise<T[]>;
-    getRange<T>(keyLowRange: any | any[], keyHighRange: any | any[], lowRangeExclusive?: boolean, highRangeExclusive?: boolean, reverse?: boolean, limit?: number, offset?: number): SyncTasks.Promise<T[]>;
-}
-export interface DbStore {
-    get<T>(key: any | any[]): SyncTasks.Promise<T>;
-    getMultiple<T>(keyOrKeys: any | any[]): SyncTasks.Promise<T[]>;
-    put(itemOrItems: any | any[]): SyncTasks.Promise<void>;
-    remove(keyOrKeys: any | any[]): SyncTasks.Promise<void>;
-    openPrimaryKey(): DbIndex;
-    openIndex(indexName: string): DbIndex;
-    clearAllData(): SyncTasks.Promise<void>;
-}
-export interface DbTransaction {
-    getStore(storeName: string): DbStore;
-}
-export declare abstract class DbProvider {
-    protected _schema: DbSchema;
-    protected _verbose: boolean;
-    open(dbName: string, schema: DbSchema, wipeIfExists: boolean, verbose: boolean): SyncTasks.Promise<void>;
-    abstract close(): SyncTasks.Promise<void>;
-    abstract openTransaction(storeNames: string | string[], writeNeeded: boolean): SyncTasks.Promise<DbTransaction>;
-    clearAllData(): SyncTasks.Promise<void>;
-    get<T>(storeName: string, key: any | any[]): SyncTasks.Promise<T>;
-    getMultiple<T>(storeName: string, keyOrKeys: any | any[]): SyncTasks.Promise<T[]>;
-    put(storeName: string, itemOrItems: any | any[]): SyncTasks.Promise<void>;
-    remove(storeName: string, keyOrKeys: any | any[]): SyncTasks.Promise<void>;
-    getAll<T>(storeName: string, indexName?: string, reverse?: boolean, limit?: number, offset?: number): SyncTasks.Promise<T[]>;
-    getOnly<T>(storeName: string, indexName: string, key: any | any[], reverse?: boolean, limit?: number, offset?: number): SyncTasks.Promise<T[]>;
-    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 './NoSqlProviderInterfaces';
 export * from './CordovaNativeSqliteProvider';
 export * from './IndexedDbProvider';
 export * from './InMemoryProvider';

dist/NoSqlProviderInterfaces.d.ts

@@ -0,0 +1,57 @@
+/**
+ * NoSqlProviderInterfaces.ts
+ * Author: David de Regt
+ * Copyright: Microsoft 2016
+ *
+ * Basic interfaces and openListOfProviders function to export for module usage.
+ */
+import SyncTasks = require('synctasks');
+export interface IndexSchema {
+    name: string;
+    keyPath: string | string[];
+    unique?: boolean;
+    multiEntry?: boolean;
+}
+export interface StoreSchema {
+    name: string;
+    indexes?: IndexSchema[];
+    primaryKeyPath: string | string[];
+}
+export interface DbSchema {
+    version: number;
+    lastUsableVersion?: number;
+    stores: StoreSchema[];
+}
+export interface DbIndex {
+    getAll<T>(reverse?: boolean, limit?: number, offset?: number): SyncTasks.Promise<T[]>;
+    getOnly<T>(key: any | any[], reverse?: boolean, limit?: number, offset?: number): SyncTasks.Promise<T[]>;
+    getRange<T>(keyLowRange: any | any[], keyHighRange: any | any[], lowRangeExclusive?: boolean, highRangeExclusive?: boolean, reverse?: boolean, limit?: number, offset?: number): SyncTasks.Promise<T[]>;
+}
+export interface DbStore {
+    get<T>(key: any | any[]): SyncTasks.Promise<T>;
+    getMultiple<T>(keyOrKeys: any | any[]): SyncTasks.Promise<T[]>;
+    put(itemOrItems: any | any[]): SyncTasks.Promise<void>;
+    remove(keyOrKeys: any | any[]): SyncTasks.Promise<void>;
+    openPrimaryKey(): DbIndex;
+    openIndex(indexName: string): DbIndex;
+    clearAllData(): SyncTasks.Promise<void>;
+}
+export interface DbTransaction {
+    getStore(storeName: string): DbStore;
+}
+export declare abstract class DbProvider {
+    protected _schema: DbSchema;
+    protected _verbose: boolean;
+    open(dbName: string, schema: DbSchema, wipeIfExists: boolean, verbose: boolean): SyncTasks.Promise<void>;
+    abstract close(): SyncTasks.Promise<void>;
+    abstract openTransaction(storeNames: string | string[], writeNeeded: boolean): SyncTasks.Promise<DbTransaction>;
+    clearAllData(): SyncTasks.Promise<void>;
+    get<T>(storeName: string, key: any | any[]): SyncTasks.Promise<T>;
+    getMultiple<T>(storeName: string, keyOrKeys: any | any[]): SyncTasks.Promise<T[]>;
+    put(storeName: string, itemOrItems: any | any[]): SyncTasks.Promise<void>;
+    remove(storeName: string, keyOrKeys: any | any[]): SyncTasks.Promise<void>;
+    getAll<T>(storeName: string, indexName?: string, reverse?: boolean, limit?: number, offset?: number): SyncTasks.Promise<T[]>;
+    getOnly<T>(storeName: string, indexName: string, key: any | any[], reverse?: boolean, limit?: number, offset?: number): SyncTasks.Promise<T[]>;
+    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>;

dist/NoSqlProviderInterfaces.js

@@ -0,0 +1,102 @@
+/**
+ * NoSqlProviderInterfaces.ts
+ * Author: David de Regt
+ * Copyright: Microsoft 2016
+ *
+ * Basic interfaces and openListOfProviders function to export for module usage.
+ */
+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.
+var DbProvider = (function () {
+    function DbProvider() {
+    }
+    DbProvider.prototype.open = function (dbName, schema, wipeIfExists, verbose) {
+        // virtual call
+        this._schema = schema;
+        this._verbose = verbose;
+        return null;
+    };
+    DbProvider.prototype.clearAllData = function () {
+        var storeNames = this._schema.stores.map(function (store) { return store.name; });
+        return this.openTransaction(storeNames, true).then(function (trans) {
+            var clearers = storeNames.map(function (name) {
+                var store = trans.getStore(name);
+                return store.clearAllData();
+            });
+            return SyncTasks.whenAll(clearers).then(function (rets) { return void 0; });
+        });
+    };
+    // Shortcut functions
+    DbProvider.prototype.get = function (storeName, key) {
+        return this.openTransaction(storeName, false).then(function (trans) {
+            var store = trans.getStore(storeName);
+            return store.get(key);
+        });
+    };
+    DbProvider.prototype.getMultiple = function (storeName, keyOrKeys) {
+        return this.openTransaction(storeName, false).then(function (trans) {
+            var store = trans.getStore(storeName);
+            return store.getMultiple(keyOrKeys);
+        });
+    };
+    DbProvider.prototype.put = function (storeName, itemOrItems) {
+        return this.openTransaction(storeName, true).then(function (trans) {
+            var store = trans.getStore(storeName);
+            return store.put(itemOrItems);
+        });
+    };
+    DbProvider.prototype.remove = function (storeName, keyOrKeys) {
+        return this.openTransaction(storeName, true).then(function (trans) {
+            var store = trans.getStore(storeName);
+            return store.remove(keyOrKeys);
+        });
+    };
+    DbProvider.prototype.getAll = function (storeName, indexName, reverse, limit, offset) {
+        return this.openTransaction(storeName, false).then(function (trans) {
+            var store = trans.getStore(storeName);
+            var index = indexName ? store.openIndex(indexName) : store.openPrimaryKey();
+            return index.getAll(reverse, limit, offset);
+        });
+    };
+    DbProvider.prototype.getOnly = function (storeName, indexName, key, reverse, limit, offset) {
+        return this.openTransaction(storeName, false).then(function (trans) {
+            var store = trans.getStore(storeName);
+            var index = indexName ? store.openIndex(indexName) : store.openPrimaryKey();
+            return index.getOnly(key, reverse, limit, offset);
+        });
+    };
+    DbProvider.prototype.getRange = function (storeName, indexName, keyLowRange, keyHighRange, lowRangeExclusive, highRangeExclusive, reverse, limit, offset) {
+        return this.openTransaction(storeName, false).then(function (trans) {
+            var store = trans.getStore(storeName);
+            var index = indexName ? store.openIndex(indexName) : store.openPrimaryKey();
+            return index.getRange(keyLowRange, keyHighRange, lowRangeExclusive, highRangeExclusive, reverse, limit, offset);
+        });
+    };
+    return DbProvider;
+})();
+exports.DbProvider = DbProvider;
+// Runs down the given providers in order and tries to instantiate them.  If they're not supported, it will continue until it finds one
+// that does work, or it will reject the promise if it runs out of providers and none work.
+function openListOfProviders(providersToTry, dbName, schema, wipeIfExists, verbose) {
+    if (wipeIfExists === void 0) { wipeIfExists = false; }
+    if (verbose === void 0) { verbose = false; }
+    var task = SyncTasks.Defer();
+    var providerIndex = 0;
+    var tryNext = function () {
+        if (providerIndex >= providersToTry.length) {
+            task.reject();
+            return;
+        }
+        var provider = providersToTry[providerIndex];
+        provider.open(dbName, schema, wipeIfExists, verbose).then(function () {
+            task.resolve(provider);
+        }, function () {
+            providerIndex++;
+            tryNext();
+        });
+    };
+    tryNext();
+    return task.promise();
+}
+exports.openListOfProviders = openListOfProviders;

dist/NodeSqlite3MemoryDbProvider.d.ts

@@ -7,7 +7,7 @@
  * Largely only used for unit tests.
  */
 import SyncTasks = require('synctasks');
-import NoSqlProvider = require('./NoSqlProvider');
+import NoSqlProvider = require('./NoSqlProviderInterfaces');
 import SqlProviderBase = require('./SqlProviderBase');
 export declare class NodeSqlite3MemoryDbProvider extends SqlProviderBase.SqlProviderBase {
     private _sqlite3;

dist/ReactNativeSqliteProvider.d.ts

@@ -6,7 +6,7 @@
  * NoSqlProvider provider setup for react-native-sqlite, a React Native plugin that wraps sqlite.
  */
 import SyncTasks = require('synctasks');
-import NoSqlProvider = require('./NoSqlProvider');
+import NoSqlProvider = require('./NoSqlProviderInterfaces');
 import SqlProviderBase = require('./SqlProviderBase');
 export declare class ReactNativeSqliteProvider extends SqlProviderBase.SqlProviderBase {
     private _reactNativeSqlite;