Initial update to support Hapi v17

Author: Greg Wilson

package-lock.json

@@ -1,10 +1,10 @@
 {
   "name": "typescript-node",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "",
   "license": "MIT",
   "repository": {
-    "url": "https://github.com/Talento90/typescript-node.git"
+    "url": "https://github.com/dwyl/hapi-typescript-example.git"
   },
   "author": "Talento90",
   "keywords": [
@@ -22,48 +22,48 @@
     "watch": "nodemon --watch build/src build/src/index.js"
   },
   "dependencies": {
+    "@salzhrani/hapi-auth-jwt2": "^7.3.0",
     "bcryptjs": "^2.4.3",
-    "boom": "^4.3.1",
+    "boom": "~7.1.0",
     "fs": "0.0.1-security",
-    "good": "^7.2.0",
-    "good-console": "^6.4.0",
+    "good": "^8.1.0",
+    "good-console": "^7.0.1",
     "good-squeeze": "^5.0.2",
-    "hapi": "^16.1.1",
-    "hapi-auth-jwt2": "^7.2.4",
-    "hapi-swagger": "^7.7.0",
-    "inert": "^4.2.0",
-    "joi": "^10.5.0",
-    "jsonwebtoken": "^7.4.1",
-    "mongoose": "^4.10.0",
-    "nconf": "^0.8.4",
+    "hapi": "17.2.0",
+    "hapi-swagger": "^9.1.1",
+    "inert": "~5.1.0",
+    "joi": "~13.1.2",
+    "jsonwebtoken": "^8.1.1",
+    "mongoose": "^5.0.4",
+    "nconf": "^0.10.0",
     "nodemon": "^1.11.0",
     "path": "^0.12.7",
-    "vision": "^4.1.1"
+    "vision": "~5.3.1"
   },
   "devDependencies": {
     "@types/bcryptjs": "^2.4.0",
-    "@types/boom": "^4.3.2",
-    "@types/chai": "^3.5.2",
-    "@types/hapi": "^16.1.2",
-    "@types/joi": "^10.3.2",
+    "@types/boom": "^7.1.1",
+    "@types/chai": "^4.1.2",
+    "@types/hapi": "^17.0.0",
+    "@types/joi": "^13.0.5",
     "@types/jsonwebtoken": "^7.2.0",
     "@types/mocha": "^2.2.41",
-    "@types/mongoose": "^4.7.13",
-    "@types/nconf": "0.0.34",
-    "@types/node": "^7.0.21",
-    "@types/sinon": "^2.2.2",
-    "chai": "^3.5.0",
+    "@types/mongoose": "^5.0.1",
+    "@types/nconf": "0.0.37",
+    "@types/node": "^9.4.5",
+    "@types/sinon": "^4.1.3",
+    "chai": "^4.1.2",
     "gulp": "^3.9.1",
     "gulp-env": "^0.4.0",
-    "gulp-mocha": "^4.3.1",
+    "gulp-mocha": "^5.0.0",
     "gulp-rimraf": "^0.2.1",
     "gulp-shell": "^0.6.3",
     "gulp-tslint": "^8.0.0",
-    "mocha": "^3.4.1",
-    "node": "0.0.0",
-    "sinon": "^2.2.0",
-    "tslint": "^5.2.0",
-    "typescript": "^2.3.2"
+    "mocha": "^5.0.0",
+    "node": "9.5.0",
+    "sinon": "^4.3.0",
+    "tslint": "^5.4.3",
+    "typescript": "^2.4.1"
   },
   "engines": {
     "node": ">=7.6.0"

package.json

@@ -1,6 +1,6 @@
 {
     "database": {
-        "connectionString": "mongodb://localhost:27017/taskdb-dev"
+        "connectionString": "mongodb://localhost:32768/taskdb-dev"
     },
     "server": {
         "port": 5000,

src/configurations/config.dev.json

@@ -1,6 +1,6 @@
 {
     "database": {
-        "connectionString": "mongodb://localhost:27017/taskdb-test"
+        "connectionString": "mongodb://localhost:32768/taskdb-test"
     },
     "server": {
         "port": 5000,

src/configurations/config.test.json

@@ -2,7 +2,7 @@ import * as Server from "./server";
 import * as Database from "./database";
 import * as Configs from "./configurations";
 
-console.log(`Running enviroment ${process.env.NODE_ENV || "dev"}`);
+console.log(`Running enviroment ${process.env.NODE_ENV || 'dev'}`);
 
 // Catch unhandling unexpected exceptions
 process.on('uncaughtException', (error: Error) => {
@@ -14,15 +14,27 @@ process.on('unhandledRejection', (reason: any) => {
     console.error(`unhandledRejection ${reason}`);
 });
 
+// Define async start function
+const start = async ({ config, db }) => {
+    try {
+        const server = await Server.init(config, db);
+        await server.start();
+        console.log('Server running at:', server.info.uri);
+    } catch (err) {
+        console.error('Error starting server: ', err.message);
+        throw err;
+    }
+};
+
 // Init Database
 const dbConfigs = Configs.getDatabaseConfig();
 const database = Database.init(dbConfigs);
 
 // Starting Application Server
 const serverConfigs = Configs.getServerConfigs();
 
-Server.init(serverConfigs, database).then((server) => {
-    server.start(() => {
-        console.log('Server running at:', server.info.uri);
-    });
+// Start the server
+start({
+    config: serverConfigs,
+    db: database
 });

src/index.ts

@@ -0,0 +1,20 @@
+import * as Hapi from 'hapi';
+
+export interface ICredentials extends Hapi.AuthCredentials {
+  id: string;
+}
+
+export interface IRequestAuth extends Hapi.RequestAuth {
+  credentials: ICredentials;
+}
+
+export interface IRequest extends Hapi.Request {
+  auth: IRequestAuth;
+}
+
+export interface ILoginRequest extends IRequest {
+  payload: {
+    email: string;
+    password: string;
+  };
+}

src/interfaces/request.ts

@@ -1,50 +1,55 @@
-import { IPlugin, IPluginOptions } from "../interfaces";
-import * as Hapi from "hapi";
-import { IUser, UserModel } from "../../users/user";
+import { IPlugin, IPluginOptions } from '../interfaces';
+import * as Hapi from 'hapi';
+import { IUser, UserModel } from '../../users/user';
+import { IRequest } from '../../interfaces/request';
+
+const register = async (server: Hapi.Server, options: IPluginOptions): Promise<void> => {
+    try {
+        const database = options.database;
+        const serverConfig = options.serverConfigs;
+
+        const validateUser = async (decoded: any, request: IRequest, h: Hapi.ResponseToolkit) => {
+            const user = await database.userModel.findById(decoded.id).lean(true);
+            if (!user) {
+                return { isValid: false };
+            }
+
+            return { isValid: true };
+        };
+
+        await server.register(require('@salzhrani/hapi-auth-jwt2'));
+
+        return setAuthStrategy(server, {
+            config: serverConfig,
+            validate: validateUser
+        });
+
+    } catch (err) {
+        console.log(`Error registering jwt plugin: ${err}`);
+        throw err;
+    }
+};
+
+const setAuthStrategy = async (server, { config, validate }) => {
+    server.auth.strategy('jwt', 'jwt', {
+        key: config.jwtSecret,
+        validate,
+        verifyOptions: { algorithms: ['HS256'] }
+    });
+
+    server.auth.default('jwt');
+
+    return;
+};
 
 export default (): IPlugin => {
     return {
-        register: (server: Hapi.Server, options: IPluginOptions): Promise<void> => {
-            const database = options.database;
-            const serverConfig = options.serverConfigs;
-
-            const validateUser = (decoded, request, cb) => {
-                database.userModel.findById(decoded.id).lean(true)
-                    .then((user: IUser) => {
-                        if (!user) {
-                            return cb(null, false);
-                        }
-
-                        return cb(null, true);
-                    });
-            };
-
-            return new Promise<void>((resolve) => {
-                server.register({
-                    register: require('hapi-auth-jwt2')
-                }, (error) => {
-                    if (error) {
-                        console.log(`Error registering jwt plugin: ${error}`);
-                    } else {
-                        server.auth.strategy('jwt', 'jwt', false,
-                            {
-                                key: serverConfig.jwtSecret,
-                                validateFunc: validateUser,
-                                verifyOptions: { algorithms: ['HS256'] }
-                            });
-                    }
-
-                    resolve();
-                });
-            });
-        },
+        register,
         info: () => {
             return {
-                name: "JWT Authentication",
-                version: "1.0.0"
+                name: 'JWT Authentication',
+                version: '1.0.0'
             };
         }
     };
 };
-
-

src/plugins/jwt-auth/index.ts

@@ -1,42 +1,44 @@
-import { IPlugin } from "../interfaces";
-import * as Hapi from "hapi";
+import { IPlugin } from '../interfaces';
+import * as Hapi from 'hapi';
 
-export default (): IPlugin => {
-    return {
-        register: (server: Hapi.Server): Promise<void> => {
-            const opts = {
+const register = async (server: Hapi.Server): Promise<void> => {
+    try {
+        return server.register({
+            plugin: require('good'),
+            options: {
                 ops: {
                     interval: 1000
                 },
                 reporters: {
-                    consoleReporter: [{
-                        module: 'good-squeeze',
-                        name: 'Squeeze',
-                        args: [{ error: '*', log: '*', response: '*', request: '*' }]
-                    }, {
-                        module: 'good-console'
-                    }, 'stdout']
+                    consoleReporter: [
+                        {
+                            module: 'good-squeeze',
+                            name: 'Squeeze',
+                            args: [{ error: '*', log: '*', response: '*', request: '*' }]
+                        },
+                        {
+                            module: 'good-console'
+                        },
+                        'stdout'
+                    ]
                 }
-            };
+            }
+        });
 
-            return new Promise<void>((resolve) => {
-                server.register({
-                    register: require('good'),
-                    options: opts
-                }, (error) => {
-                    if (error) {
-                        console.log(`Error registering logger plugin: ${error}`);
-                    }
+    } catch (err) {
+        console.log(`Error registering logger plugin: ${err}`);
+        throw err;
+    }
+};
 
-                    resolve();
-                });
-            });
-        },
+export default (): IPlugin => {
+    return {
+        register,
         info: () => {
             return {
-                name: "Good Logger",
-                version: "1.0.0"
+                name: 'Good Logger',
+                version: '1.0.0'
             };
         }
     };
-};
+};