Merge pull request #42 from hapinessjs/next

release(version): v2.0.0

Author: akanass

README.md

@@ -33,7 +33,7 @@
 
 # Mongo Module
 
-`Mongo` module for the Hapiness framework including a `mongoose` adapter and a `mongoose-gridfs` one.
+`Mongo` module for the Hapiness framework including `mongoose`, `mongoose-gridfs` (deprecated) and `mongoose-gridfs-bucket` adapter one.
 
 ## Table of contents
 
@@ -112,7 +112,7 @@ Your adapter should be a class which inherits from `AbstractHapinessMongoAdapter
 
 ### Step 2
 
-You absolutely need to implement a static function `getInterfaceName`, which will return a uniq string identifier for your adapter (**NOTE** `mongoose` and `mongoose-gridfs` are already used by adapters provided by this module).
+You absolutely need to implement a static function `getInterfaceName`, which will return a uniq string identifier for your adapter (**NOTE** `mongoose`, `mongoose-gridfs` and `mongoose-gridfs-bucket` are already used by adapters provided by this module).
 
 ### Step 3
 
@@ -486,6 +486,11 @@ To set up your development environment:
 
 ## Change History
 
+* v2.0.0
+    * Updated mongoose to latest version
+    * Removed the call to createConnection from the constructor of mongo adapter.
+    * Now catch connection errors and pipe them out to be catch by user later on. No more waiting for timeout to realize there is a connection error.
+    * MongooseGridfsAdapter is now deprecated. Use MongooseGridfsBucketAdapter
 * v1.2.0 (2018-04-05)
     * Updated packages' versions.
     * added support of `OnShutdown` of `hapiness Core`
@@ -520,7 +525,7 @@ To set up your development environment:
 
 <table>
     <tr>
-        <td colspan="4" align="center"><a href="https://www.tadaweb.com"><img src="http://bit.ly/2xHQkTi" width="117" alt="tadaweb" /></a></td>
+        <td colspan="5" align="center"><a href="https://www.tadaweb.com"><img src="http://bit.ly/2xHQkTi" width="117" alt="tadaweb" /></a></td>
     </tr>
     <tr>
         <td align="center"><a href="https://github.com/Juneil"><img src="https://avatars3.githubusercontent.com/u/6546204?v=3&s=117" width="117"/></a></td>

package-lock.json

@@ -1,6 +1,6 @@
 {
     "name": "@hapiness/mongo",
-    "version": "1.2.0",
+    "version": "2.0.0",
     "description": "Hapiness Module for MongoDB usage",
     "main": "commonjs/index.js",
     "types": "index.d.ts",
@@ -71,11 +71,12 @@
     "homepage": "https://github.com/hapinessjs/mongo-module#readme",
     "dependencies": {
         "@types/gridfs-stream": "^0.5.30",
-        "@types/mongoose": "^4.7.32",
-        "@types/node": "^9.6.0",
+        "@types/mongodb": "^3.0.9",
+        "@types/mongoose": "^5.0.7",
+        "@types/node": "^9.6.2",
         "debug": "^3.1.0",
         "gridfs-stream": "^1.1.1",
-        "mongoose": "^4.13.9"
+        "mongoose": "^5.0.12"
     },
     "devDependencies": {
         "@hapiness/core": "^1.5.0",

package.json

@@ -40,20 +40,10 @@ export class HapinessMongoAdapter extends EventEmitter {
         }
 
         this._modelManager = new ModelManager();
-
-        this
-            .connect()
-            .subscribe(_ => {
-                __debugger.debug('constructor', 'OK');
-            }, (err) => {
-                __debugger.debug('constructor', `Err catched :: ${err.message}`);
-                __debugger.debug('constructor', `Err catched :: ${JSON.stringify(err, null, 2)}`);
-            });
     }
 
     public connect(): Observable<void> {
         this._connection = null;
-
         const db = this._config.db || this._config.database;
 
         if (this._config.url) {
@@ -64,7 +54,13 @@ export class HapinessMongoAdapter extends EventEmitter {
             return Observable.throw(new Error('No db name nor url provided'));
         }
 
-        return this.tryConnect();
+        return this.tryConnect()
+            .do(() => __debugger.debug('connect', 'OK'))
+            .catch(err => {
+                __debugger.debug('connect', `Err catched :: ${err.message}`);
+                __debugger.debug('connect', `Err catched :: ${JSON.stringify(err, null, 2)}`);
+                return Observable.throw(err);
+            });
     }
 
     public tryConnect(): Observable<void> {

src/module/adapters/hapiness-mongo-adapter.ts

@@ -1,4 +1,5 @@
 export * from './hapiness-mongo-adapter';
 export * from './mongoose-gridfs';
+export * from './mongoose-gridfs-bucket-adapter';
 export * from './mongoose-adapter';
 export * from './interfaces/index';

src/module/adapters/index.ts

@@ -23,43 +23,26 @@ export class MongooseAdapter extends HapinessMongoAdapter {
             .create(observer => {
                 this._isReady = false;
 
-                if (this._db && !this._db.close) {
-                    return observer.error(new Error('_db needs a close function.'));
-                }
-
-                if (this._db) {
-                    __debugger.debug('_tryConnect', 'db already exists');
-                    this._db.close();
-                }
-
-                const connectOptions = {
-                    server: {
-                        reconnectTries: Number.MAX_VALUE,
-                        reconnectInterval: 5000,
-                    },
+                const connectOptions: mongoose.ConnectionOptions = {
+                    promiseLibrary: global.Promise,
+                    reconnectTries: Number.MAX_VALUE,
+                    reconnectInterval: 5000,
                 };
 
-                this._connection = mongoose.createConnection(this._uri, connectOptions);
-
-                this._connection.once('connected', () => {
-                    __debugger.debug('_tryConnect', 'connection once connected');
+                this._connection = mongoose.createConnection(this._uri, connectOptions)
 
+                // Seems that typings are not up to date at the moment
+                this._connection['then'](() => {
                     observer.next();
                     observer.complete();
-                });
-
-                this._connection.once('error', err => {
-                    __debugger.debug('_tryConnect', `connection once error ${JSON.stringify(err, null, 2)}`);
-
-                    observer.error(err);
-                });
+                })
+                .catch(err => observer.error(err));
             });
     }
 
     protected _afterConnect(): Observable<void> {
         return Observable
             .create(observer => {
-                this._db = this._connection.db;
 
                 this.onConnected().subscribe(_ => {
                     __debugger.debug('_afterConnect', '(subscribe) On connected success');
@@ -100,6 +83,6 @@ export class MongooseAdapter extends HapinessMongoAdapter {
     }
 
     public close(): Observable<void> {
-        return Observable.fromPromise(this._db.close());
+        return Observable.fromPromise(this._connection.client.close());
     }
 }

src/module/adapters/mongoose-adapter.ts

@@ -0,0 +1,93 @@
+import * as mongoose from 'mongoose';
+import * as mongo from 'mongodb';
+
+import { Observable } from 'rxjs/Observable';
+import { HapinessMongoAdapter } from './hapiness-mongo-adapter';
+import { Debugger } from '../shared';
+
+const __debugger = new Debugger('MongooseGridfsBucketAdapter');
+
+(<any>mongoose).Promise = global.Promise;
+
+export class MongooseGridFsBucketAdapter extends HapinessMongoAdapter {
+    private _gridfsBucket: mongo.GridFSBucket;
+
+    public static getInterfaceName(): string {
+        return 'mongoose-gridfs-bucket';
+    }
+
+    constructor(options) {
+        super(options);
+    }
+
+    protected _tryConnect(): Observable<void> {
+        return Observable
+            .create(observer => {
+                this._isReady = false;
+
+                const connectOptions: mongoose.ConnectionOptions = {
+                    reconnectTries: Number.MAX_VALUE,
+                    reconnectInterval: 5000,
+                };
+
+                this._connection = mongoose.createConnection(this._uri, connectOptions);
+
+                // Seems that typings are not up to date at the moment
+                this._connection['then'](connection => {
+                    observer.next();
+                    observer.complete();
+                })
+                .catch(err => {
+                    observer.error(err);
+                });
+            });
+    }
+
+    protected _afterConnect(): Observable<void> {
+        return Observable
+            .create(observer => {
+                this._gridfsBucket = new mongoose.mongo.GridFSBucket((<mongoose.Connection>this._connection).db);
+
+                this.onConnected().subscribe(_ => {
+                    __debugger.debug('_afterConnect', '(subscribe) On connected success');
+                }, (e) => {
+                    __debugger.debug('_afterConnect', `(subscribe) On connected failed ${JSON.stringify(e, null, 2)}`);
+                });
+
+                this._connection.once('error', err =>
+                    this.onError(err).subscribe(_ => {
+                        __debugger.debug('_afterConnect', '(subscribe) On connection error #success');
+                    }, (e) => {
+                        __debugger.debug('_afterConnect', `(subscribe) On connection error #failed ${JSON.stringify(e, null, 2)}`);
+                    })
+                );
+
+                this._connection.once('disconnected', () =>
+                    this.onDisconnected().subscribe(_ => {
+                        __debugger.debug('_afterConnect', '(subscribe) On connection disconnected #success');
+                    }, (e) => {
+                        __debugger.debug('_afterConnect', `(subscribe) On connection disconnected #failed ${JSON.stringify(e, null, 2)}`);
+                    })
+                );
+
+                observer.next();
+                observer.complete();
+            });
+    }
+
+    public registerValue(schema: any, collection: string, collectionName?: string) {
+        if (!!collectionName && collectionName.length) {
+            return this._connection.model(collection, schema, collectionName);
+        }
+        return this._connection.model(collection, schema);
+    }
+
+    public getLibrary(): any {
+        return this._gridfsBucket;
+    }
+
+    // It seems that there is a bug here and it never really close the connection it always try to reconnect afterwards.
+    public close(): Observable<void> {
+        return Observable.fromPromise(this._connection.client.close(true));
+    }
+}

src/module/adapters/mongoose-gridfs-bucket-adapter.ts

@@ -1,49 +1,61 @@
 import * as mongoose from 'mongoose';
+import * as util from 'util';
+
 import { Observable } from 'rxjs/Observable';
 
 import { CreateGridFsStream, GridFsStream } from '../shared/gridfs-stream';
 import { HapinessMongoAdapter } from './hapiness-mongo-adapter';
 
+/**
+ * Gridfs adapter using mongoose for connection purposes
+ *
+ * @deprecated
+ * @export
+ * @class MongooseGridFsAdapter
+ * @extends {HapinessMongoAdapter}
+ */
 export class MongooseGridFsAdapter extends HapinessMongoAdapter {
 
     private _gridfs: GridFsStream.Grid;
+    protected _client: any;
 
     public static getInterfaceName(): string {
         return 'mongoose-gridfs';
     }
 
     constructor(options) {
-        super(options);
+        super(options)
+        util.deprecate((() => null), 'MongooseGridFsAdapter is deprecated use MongooseGridfsBucketAdapter instead.')();
     }
 
     protected _tryConnect(): Observable<void> {
         return Observable
             .create(observer => {
                 this._isReady = false;
 
-                if (this._db && !this._db.close) {
-                    return observer.error(new Error('_db needs a close function.'));
+                if ((this._db && !this._db.close) || (this._client && !this._client.close)) {
+                    return observer.error(new Error('_db or _client needs a close function.'));
                 }
 
-                if (this._db) {
+                if (this._db && this._db.close) {
                     this._db.close();
+                } else if (this._client && this._client.close) {
+                    this._client.close();
                 }
 
                 const connectOptions = {
-                    server: {
-                        reconnectTries: Number.MAX_VALUE,
-                        reconnectInterval: 5000,
-                    },
+                    reconnectTries: Number.MAX_VALUE,
+                    reconnectInterval: 5000,
                 };
 
                 this._connection = mongoose.createConnection(this._uri, connectOptions);
 
-                this._connection.once('connected', () => {
+                // Seems that typings are not up to date at the moment
+                this._connection['then'](connection => {
                     observer.next();
                     observer.complete();
-                });
-
-                this._connection.once('error', err => {
+                })
+                .catch(err => {
                     observer.error(err);
                 });
             });
@@ -53,10 +65,11 @@ export class MongooseGridFsAdapter extends HapinessMongoAdapter {
         return CreateGridFsStream(db, mongo);
     }
 
-    protected _afterConnect(): Observable<void> {
+    protected _afterConnect(): Observable<void > {
         return Observable
             .create(observer => {
                 this._db = this._connection.db;
+                this._client = this._connection.client;
 
                 this._gridfs = this._createGridFsStream(this._db, mongoose.mongo);
 
@@ -75,7 +88,7 @@ export class MongooseGridFsAdapter extends HapinessMongoAdapter {
             });
     }
 
-    public registerValue(schema: any, collection: string, collectionName?: string) {
+    public registerValue(schema: any, collection: string, collectionName ?: string) {
         if (!!collectionName && collectionName.length) {
             return this._connection.model(collection, schema, collectionName);
         }
@@ -86,7 +99,7 @@ export class MongooseGridFsAdapter extends HapinessMongoAdapter {
         return this._gridfs;
     }
 
-    public close(): Observable<void> {
-        return Observable.fromPromise(this._db.close());
+    public close(): Observable<void > {
+        return Observable.fromPromise(this._client.close());
     }
 }

src/module/adapters/mongoose-gridfs.ts

@@ -16,7 +16,7 @@ export class ModelManager {
         this.models.push(item);
     }
 
-    public get(token: Type<any>) {
+    public get<T = any>(token: Type<any>): T | undefined {
         const item = this.models.find(_ => _.token === token);
         return item ? item.value : undefined;
     }