Allow plugins to register handler types

lib/handler.js

@@ -7,7 +7,6 @@ var Utils = require('./utils');
 var Response = require('./response');
 var Ext = require('./ext');
 var File = require('./file');
-var Directory = require('./directory');
 var Proxy = require('./proxy');
 var Views = require('./views');
 var Methods = require('./methods');
@@ -197,21 +196,13 @@ internals.wrap = function (result, request, finalize) {
 exports.configure = function (handler, route) {
 
     if (typeof handler === 'object') {
-        if (handler.proxy) {
-            return Proxy.handler(route, handler.proxy);
-        }
 
-        if (handler.file) {
-            return File.handler(route, handler.file);
-        }
+        var type = Object.keys(handler)[0];
+        var func = type && route.server.handlers[type];
 
-        if (handler.directory) {
-            return Directory.handler(route, handler.directory);
-        }
+        Utils.assert(func, 'Unknown handler:', type);
 
-        if (handler.view) {
-            return Views.handler(route, handler.view);
-        }
+        return func(route, handler[type]);
     }
 
     if (typeof handler === 'string') {

lib/pack.js

@@ -245,6 +245,10 @@ internals.Pack.prototype._register = function (plugin, options, callback, _depen
             ext: function () {
 
                 self._applySync(selection.servers, Server.prototype._ext, [arguments[0], arguments[1], arguments[2], env]);
+            },
+            handler: function (name, method, schema) {
+
+                self._applySync(selection.servers, Server.prototype.handler, [name, method, schema]);
             }
         };
 

lib/route.js

@@ -36,6 +36,9 @@ exports = module.exports = internals.Route = function (options, server, env) {
     schemaError = Schema.routeConfig(this.settings);
     Utils.assert(!schemaError, 'Invalid route config for', options.path, ':', schemaError);
 
+    schemaError = Schema.routeHandler(this.settings.handler, server.handlerSchema);
+    Utils.assert(!schemaError, 'Invalid route handler for', options.path, ':', schemaError);
+
     this.server = server;
     this.env = env || {};                                           // Plugin-specific environment
     this.method = options.method.toLowerCase();

lib/schema.js

@@ -128,7 +128,7 @@ internals.routeOptionsSchema = {
     method: Joi.alternatives(Joi.string(), Joi.array().includes(Joi.string()).min(1)).required(),
     path: Joi.string().required(),
     vhost: [Joi.string(), Joi.array()],
-    handler: Joi.any(),                         // Validated in route.config
+    handler: Joi.any(),                         // Validated in routeHandler()
     config: Joi.object().allow(null)
 };
 
@@ -156,53 +156,7 @@ internals.pre = [
 
 internals.routeConfigSchema = {
     pre: Joi.array().includes(internals.pre.concat(Joi.array().includes(internals.pre).min(1))),
-    handler: [
-        Joi.func(),
-        Joi.string(),
-        Joi.object({
-            directory: Joi.object({
-                path: Joi.alternatives(Joi.string(), Joi.array().includes(Joi.string()), Joi.func()).required(),
-                index: Joi.boolean(),
-                listing: Joi.boolean(),
-                showHidden: Joi.boolean(),
-                redirectToSlash: Joi.boolean(),
-                lookupCompressed: Joi.boolean(),
-                defaultExtension: Joi.string().alphanum()
-            }),
-            file: [
-                Joi.string(),
-                Joi.func(),
-                Joi.object({
-                    path: Joi.string().required(),
-                    filename: Joi.string().with('mode'),
-                    mode: Joi.string().valid('attachment', 'inline').allow(false),
-                    lookupCompressed: Joi.boolean()
-                })
-            ],
-            proxy: Joi.object({
-                host: Joi.string().xor('mapUri', 'uri'),
-                port: Joi.number().integer().without('mapUri', 'uri'),
-                protocol: Joi.string().valid('http', 'https', 'http:', 'https:').without('mapUri', 'uri'),
-                uri: Joi.string().without('host', 'port', 'protocol', 'mapUri'),
-                passThrough: Joi.boolean(),
-                rejectUnauthorized: Joi.boolean(),
-                xforward: Joi.boolean(),
-                redirects: Joi.number().min(0).integer().allow(false),
-                timeout: Joi.number().integer(),
-                mapUri: Joi.func().without('host', 'port', 'protocol', 'uri'),
-                onResponse: Joi.func(),
-                postResponse: Joi.func(),                                           // Backward compatibility
-                ttl: Joi.string().valid('upstream').allow(null)
-            }),
-            view: [
-                Joi.string(),
-                Joi.object({
-                    template: Joi.string(),
-                    context: Joi.object()
-                })
-            ]
-        }).length(1)
-    ],
+    handler: Joi.any(),                         // Validated in routeHandler()
     bind: Joi.object().allow(null),
     payload: Joi.object({
         output: Joi.string().valid('data', 'stream', 'file'),
@@ -253,6 +207,72 @@ internals.routeConfigSchema = {
 };
 
 
+// Validate route handler
+
+exports.routeHandler = function (config, handlerSchema) {
+
+    var schema = Utils.clone(internals.routeHandlerSchema);
+    var error;
+
+    schema.push(Joi.object(handlerSchema).length(1));
+    error = Joi.validate(config, schema);
+
+    return (error ? error.annotated() : null);
+};
+
+
+// Not a joi object.  Route handler schema is compiled based on registered handler types
+exports.routeHandlerObjectSchema = {
+    directory: Joi.object({
+        path: Joi.alternatives(Joi.string(), Joi.array().includes(Joi.string()), Joi.func()).required(),
+        index: Joi.boolean(),
+        listing: Joi.boolean(),
+        showHidden: Joi.boolean(),
+        redirectToSlash: Joi.boolean(),
+        lookupCompressed: Joi.boolean(),
+        defaultExtension: Joi.string().alphanum()
+    }),
+    file: [
+        Joi.string(),
+        Joi.func(),
+        Joi.object({
+            path: Joi.string().required(),
+            filename: Joi.string().with('mode'),
+            mode: Joi.string().valid('attachment', 'inline').allow(false),
+            lookupCompressed: Joi.boolean()
+        })
+    ],
+    proxy: Joi.object({
+        host: Joi.string().xor('mapUri', 'uri'),
+        port: Joi.number().integer().without('mapUri', 'uri'),
+        protocol: Joi.string().valid('http', 'https', 'http:', 'https:').without('mapUri', 'uri'),
+        uri: Joi.string().without('host', 'port', 'protocol', 'mapUri'),
+        passThrough: Joi.boolean(),
+        rejectUnauthorized: Joi.boolean(),
+        xforward: Joi.boolean(),
+        redirects: Joi.number().min(0).integer().allow(false),
+        timeout: Joi.number().integer(),
+        mapUri: Joi.func().without('host', 'port', 'protocol', 'uri'),
+        onResponse: Joi.func(),
+        postResponse: Joi.func(),                                           // Backward compatibility
+        ttl: Joi.string().valid('upstream').allow(null)
+    }),
+    view: [
+        Joi.string(),
+        Joi.object({
+            template: Joi.string(),
+            context: Joi.object()
+        })
+    ]
+};
+
+
+internals.routeHandlerSchema = [
+    Joi.func(),
+    Joi.string()
+];
+
+
 exports.view = function (options) {
 
     var schema = internals.viewSchema({

lib/server.js

@@ -13,10 +13,14 @@ var Defaults = require('./defaults');
 var Request = require('./request');
 var Router = require('./router');
 var Schema = require('./schema');
+var File = require('./file');
+var Proxy = require('./proxy');
+var Directory = require('./directory');
 var Views = require('./views');
 var Ext = require('./ext');
 var Handler = require('./handler');
 var Utils = require('./utils');
+var Joi = require('joi');
 // Pack delayed required inline
 
 
@@ -218,6 +222,19 @@ exports = module.exports = internals.Server = function (/* host, port, options *
             this.info.uri = this.info.protocol + '://' + (this._host || Os.hostname() || 'localhost') + ':' + this.info.port;
         }
     }
+
+    this.handlers = {
+        proxy: Proxy.handler,
+        file: File.handler,
+        directory: Directory.handler,
+        view: Views.handler
+    };
+    this.handlerSchema = {
+        proxy: Schema.routeHandlerObjectSchema.proxy,
+        file: Schema.routeHandlerObjectSchema.file,
+        directory: Schema.routeHandlerObjectSchema.directory,
+        view: Schema.routeHandlerObjectSchema.view
+    };
 };
 
 Utils.inherits(internals.Server, Events.EventEmitter);
@@ -469,3 +486,13 @@ internals.Server.prototype.method = function () {
 
     return this.pack._method.apply(this.pack, arguments);
 };
+
+
+internals.Server.prototype.handler = function (name, method, schema) {
+
+    Utils.assert(typeof name === 'string', 'Invalid handler name');
+    Utils.assert(typeof method === 'function', 'Handler must be a function:', name);
+    schema = schema || Joi.any();
+    this.handlers[name] = method;
+    this.handlerSchema[name] = schema;
+};

test/pack.js

@@ -821,4 +821,43 @@ describe('Pack', function () {
             done();
         });
     });
+
+    describe('#handler', function () {
+
+        it('add new handler', function (done) {
+
+            var server = new Hapi.Server();
+            var plugin = {
+                name: 'foo',
+                version: '0.0.1',
+                register: function (plugin, options, next) {
+
+                    plugin.handler('bar', function (route, options) {
+
+                        return function (request, reply) {
+
+                            reply('success');
+                        };
+                    });
+                    next();
+                }
+            };
+
+            server.pack.register(plugin, function (err) {
+
+                expect(err).to.not.exist;
+                server.route({
+                    method: 'GET',
+                    path: '/',
+                    handler: {
+                        bar: {}
+                    }
+                });
+                server.inject('/', function (res) {
+                    expect(res.payload).to.equal('success');
+                    done();
+                });
+            });
+        });
+    });
 });

test/schema.js

@@ -149,4 +149,15 @@ describe('Schema', function () {
             done();
         });
     });
+
+    describe('#routeHandler', function () {
+
+        it('fails when route has duplicate handler', function (done) {
+
+            var handler = { file: 'something', view: 'something' };
+
+            expect(Schema.routeHandler(handler)).to.exist;
+            done();
+        });
+    });
 });