Merge pull request #12 from firstandthird/hapi17

Hapi17

Author: orthagonal

.travis.yml

@@ -1,4 +1,3 @@
 language: node_js
 node_js:
   - "8"
-  - "6"

index.js

@@ -2,26 +2,26 @@
 const useragent = require('useragent');
 const wreck = require('wreck');
 
-module.exports = (server, options, allDone) => {
+const register = async (server, options) => {
   options = options || {};
   if (!options.method) {
-    return allDone(new Error('hapi-trailing-slash plugin registered without specifiying which method to use'));
+    throw new Error('hapi-trailing-slash plugin registered without specifiying which method to use');
   }
   options.statusCode = options.statusCode || 301;
 
-  const redirectExists = (redirectPath, callback) => {
+  const redirectExists = async (redirectPath) => {
     if (!options.checkIfExists) {
-      return callback(true);
+      return Promise.resolve(true);
+    }
+    try {
+      const { res, payload } = await wreck.request('head', redirectPath);
+      return Promise.resolve(res.statusCode < 400);
+    } catch (e) {
+      return Promise.resolve(false);
     }
-    wreck.request('head', redirectPath, {}, (err, res) => {
-      if (err) {
-        return callback(false);
-      }
-      return callback(res.statusCode < 400);
-    });
   };
 
-  const doRedirect = (path, request, reply) => {
+  const doRedirect = (path, request, h) => {
     const redirectTo = request.url.search ? path + request.url.search : path;
     if (options.verbose) {
       server.log(['hapi-trailing-slash', 'redirect'], {
@@ -34,15 +34,21 @@ module.exports = (server, options, allDone) => {
         to: redirectTo
       });
     }
-    return reply.redirect(redirectTo).code(options.statusCode);
+    const response = h.redirect(redirectTo)
+    // redirects in hapi 17 are either permanent() or temporary()
+    if (options.statusCode === 301) {
+      return response.permanent();
+    }
+    else {
+      return response.temporary();
+    }
   };
 
-  // if (options.method === 'append') {
-  server.ext('onPreResponse', (request, reply) => {
+  server.ext('onPreResponse', async(request, h) => {
     const statusCode = request.response.output ? request.response.output.statusCode : request.response.statusCode;
     // if the route was already found by hapi then just ignore it:
     if (statusCode !== 404) {
-      return reply.continue();
+      return h.continue;
     }
     const method = request.method.toLowerCase();
     // pick a condition checker based on either 'append' or 'remove' mode:
@@ -51,25 +57,25 @@ module.exports = (server, options, allDone) => {
     // see if we need to do a redirect for either slashed/slashless path:
     if (['get', 'head'].indexOf(method) !== -1 && condition()) {
       if (request.path.indexOf('.') !== -1) {
-        return reply.continue();
+        return h.continue;
       }
       // pick a redirection based on either 'append' or 'remove' mode:
       const redirectPath = options.method === 'append' ? `${request.path}/` : request.path.replace(/\/$/, '');
-      return redirectExists(redirectPath, (exists) => {
-        if (exists) {
-          doRedirect(redirectPath, request, reply);
-        } else {
-          return reply.continue();
-        }
-      });
+      const exists = await redirectExists(redirectPath);
+      if (exists) {
+        return doRedirect(redirectPath, request, h);
+      } else {
+        return h.continue;
+      }
     }
     // otherwise it really is a 404:
-    return reply.continue();
+    return h.continue;
   });
-  allDone();
+  return Promise.resolve();
 };
 
-module.exports.attributes = {
-  name: 'hapi-trailing-slash',
+exports.plugin = {
+  register,
+  once: true,
   pkg: require('./package.json')
 };

package.json

@@ -25,11 +25,11 @@
     "eslint": "^3.9.1",
     "eslint-config-firstandthird": "^3.2.0",
     "eslint-plugin-import": "^2.1.0",
-    "hapi": "^16.1.1",
-    "lab": "^13.0.1"
+    "hapi": "^17.0.1",
+    "lab": "^15.1.2"
   },
   "dependencies": {
     "useragent": "^2.2.1",
-    "wreck": "^12.0.0"
+    "wreck": "^14.0.2"
   }
 }

test/append.test.js

@@ -8,144 +8,122 @@ const theModule = require('../index.js');
 lab.experiment('hapi-trailing-slash', () => {
   let server;
 
-  lab.beforeEach((done) => {
+  lab.beforeEach(async() => {
     server = new Hapi.Server();
-    server.connection();
-
     server.route([
       {
         method: 'GET',
         path: '/no/slash',
-        handler: (request, reply) => {
-          reply('welcome to the jungle');
+        handler: (request, h) => {
+          return 'welcome to the jungle';
         }
       },
       {
         method: 'GET',
         path: '/has/slash/',
-        handler: (request, reply) => {
-          reply('slither');
+        handler: (request, h) => {
+          return 'slither';
         }
       },
       {
         method: 'GET',
         path: '/has/slash/{band}/',
-        handler: (request, reply) => {
+        handler: (request, h) => {
           if (request.params.band === 'gnr') {
-            reply('sweet child of mine ');
+            return 'sweet child of mine ';
           } else if (request.params.band === 'velvet_revolver') {
-            reply('slither');
+            return 'slither';
           } else {
-            reply('not found');
+            return 'not found';
           }
         }
       }
     ]);
 
-    server.register({
-      register: theModule,
+    const response = await server.register({
+      plugin: theModule,
       options: {
         method: 'append',
         verbose: true
       }
-    }, (err) => {
-      if (err) {
-        throw err;
-      }
-      server.start(done);
     });
+    await server.start();
   });
 
-  lab.afterEach((done) => {
-    server.stop(done);
+  lab.afterEach(async() => {
+    await server.stop();
   });
 
-  lab.test(' "append"  /has/slash/ works normally', (done) => {
-    server.inject({
+  lab.test(' "append"  /has/slash/ works normally', async() => {
+    const result = await server.inject({
       method: 'get',
       url: '/has/slash/'
-    }, (result) => {
-      Code.expect(result.statusCode).to.equal(200);
-      Code.expect(result.payload).to.equal('slither');
-      done();
     });
+    Code.expect(result.statusCode).to.equal(200);
+    Code.expect(result.payload).to.equal('slither');
   });
-  lab.test(' "append" /has/slash works normally if that route is specified', (done) => {
+  lab.test(' "append" /has/slash works normally if that route is specified', async() => {
     server.route({
       path: '/has/slash',
       method: 'get',
-      handler(request, reply) {
-        return reply('slither');
+      handler(request, h) {
+        return 'slither';
       }
     });
-    server.inject({
+    const result = await server.inject({
       method: 'get',
       url: '/has/slash'
-    }, (result) => {
-      Code.expect(result.statusCode).to.equal(200);
-      Code.expect(result.payload).to.equal('slither');
-      done();
     });
+    Code.expect(result.statusCode).to.equal(200);
+    Code.expect(result.payload).to.equal('slither');
   });
 
-  lab.test(' "append" GET /has/slash redirects to /has/slash/', (done) => {
-    server.inject({
+  lab.test(' "append" GET /has/slash redirects to /has/slash/', async() => {
+    const result = await server.inject({
       method: 'get',
       url: '/has/slash'
-    }, (result) => {
-      Code.expect(result.statusCode).to.equal(301);
-      Code.expect(result.headers.location).to.equal('/has/slash/');
-      done();
     });
+    Code.expect(result.statusCode).to.equal(301);
+    Code.expect(result.headers.location).to.equal('/has/slash/');
   });
-  lab.test(' "append" HEAD /has/slash redirects to /has/slash/', (done) => {
-    server.inject({
+  lab.test(' "append" HEAD /has/slash redirects to /has/slash/', async() => {
+    const result = await server.inject({
       method: 'head',
       url: '/has/slash'
-    }, (result) => {
-      Code.expect(result.statusCode).to.equal(301);
-      Code.expect(result.headers.location).to.equal('/has/slash/');
-      done();
     });
+    Code.expect(result.statusCode).to.equal(301);
+    Code.expect(result.headers.location).to.equal('/has/slash/');
   });
-  lab.test(' "append"  /has/slash/ GET works with url params', (done) => {
-    server.inject({
+  lab.test(' "append"  /has/slash/ GET works with url params', async() => {
+    const result = await server.inject({
       method: 'get',
       url: '/has/slash/velvet_revolver/'
-    }, (result) => {
-      Code.expect(result.statusCode).to.equal(200);
-      Code.expect(result.payload).to.equal('slither');
-      done();
     });
+    Code.expect(result.statusCode).to.equal(200);
+    Code.expect(result.payload).to.equal('slither');
   });
 
-  lab.test(' "append" /has/slash GET redirects with url params ', (done) => {
-    server.inject({
+  lab.test(' "append" /has/slash GET redirects with url params ', async() => {
+    const result = await server.inject({
       method: 'get',
       url: '/has/slash/velvet_revolver?temp=hi'
-    }, (result) => {
-      Code.expect(result.statusCode).to.equal(301);
-      Code.expect(result.headers.location).to.equal('/has/slash/velvet_revolver/?temp=hi');
-      done();
     });
+    Code.expect(result.statusCode).to.equal(301);
+    Code.expect(result.headers.location).to.equal('/has/slash/velvet_revolver/?temp=hi');
   });
-  lab.test(' "append" /has/slash POST redirect is ignored ', (done) => {
-    server.inject({
+  lab.test(' "append" /has/slash POST redirect is ignored ', async() => {
+    const result = await server.inject({
       method: 'post',
       url: '/has/slash/velvet_revolver?temp=hi'
-    }, (result) => {
-      Code.expect(result.statusCode).to.equal(404);
-      done();
     });
+    Code.expect(result.statusCode).to.equal(404);
   });
 
-  lab.test(' "append" /has/slash.png redirect is ignored ', (done) => {
-    server.inject({
+  lab.test(' "append" /has/slash.png redirect is ignored ', async() => {
+    const result = await server.inject({
       method: 'get',
       url: '/images/logo.png'
-    }, (result) => {
-      Code.expect(result.statusCode).to.equal(404);
-      done();
     });
+    Code.expect(result.statusCode).to.equal(404);
   });
 });