module hapi
1. function hapi.Server (options)
2. function hapi.Server.super_ (server, connections, env, parent)
3. function hapi.auth (connection)
4. function hapi.compression ()
5. function hapi.connection (server, options)
6. function hapi.ext (type, server)
7. function hapi.methods (server)
8. function hapi.protect (request)
9. function hapi.reply ()
10. function hapi.request ()
11. function hapi.response (source, request, options)
12. function hapi.route (route, connection, plugin, options)
13. object hapi.Server.prototype
14. object hapi.Server.super_.prototype
15. object hapi.Server.super_.super_.prototype
16. object hapi.auth.prototype
17. object hapi.compression.prototype
18. object hapi.connection.prototype
19. object hapi.cors
20. object hapi.ext.prototype
21. object hapi.handler
22. object hapi.methods.prototype
23. object hapi.promises
24. object hapi.protect.prototype
25. object hapi.reply.prototype
26. object hapi.request.prototype
27. object hapi.response.prototype
28. object hapi.route.prototype
29. object hapi.schema
30. object hapi.transmit
31. object hapi.validation
module hapi.Server
1. function hapi.Server (options)
2. function hapi.Server.super_ (server, connections, env, parent)
module hapi.Server.prototype
1. function hapi.Server.prototype._createCache (options, _callback)
2. function hapi.Server.prototype._invoke (type, next)
3. function hapi.Server.prototype._start (callback)
4. function hapi.Server.prototype._validateDeps ()
5. function hapi.Server.prototype.connection (options)
6. function hapi.Server.prototype.initialize (callback)
7. function hapi.Server.prototype.start (callback)
8. function hapi.Server.prototype.stop ()
module hapi.Server.super_
1. function hapi.Server.super_ (events)
module hapi.Server.super_.prototype
1. function hapi.Server.super_.prototype._apply (type, func, args)
2. function hapi.Server.super_.prototype._applyChild (type, child, func, args)
3. function hapi.Server.super_.prototype._clone (connections, plugin)
4. function hapi.Server.super_.prototype._ext (event)
5. function hapi.Server.super_.prototype._log (tags, data)
6. function hapi.Server.super_.prototype._select (labels, plugin)
7. function hapi.Server.super_.prototype._single ()
8. function hapi.Server.super_.prototype.bind (context)
9. function hapi.Server.super_.prototype.cache (options, _segment)
10. function hapi.Server.super_.prototype.decoder (encoding, decoder)
11. function hapi.Server.super_.prototype.decorate (type, property, method, options)
12. function hapi.Server.super_.prototype.dependency (dependencies, after)
13. function hapi.Server.super_.prototype.emit (criteria, data, callback)
14. function hapi.Server.super_.prototype.encoder (encoding, encoder)
15. function hapi.Server.super_.prototype.event (event)
16. function hapi.Server.super_.prototype.expose (key, value)
17. function hapi.Server.super_.prototype.ext (events)
18. function hapi.Server.super_.prototype.handler (name, method)
19. function hapi.Server.super_.prototype.inject (options, callback)
20. function hapi.Server.super_.prototype.log (tags, data, timestamp, _internal)
21. function hapi.Server.super_.prototype.lookup (id)
22. function hapi.Server.super_.prototype.match (method, path, host)
23. function hapi.Server.super_.prototype.method (name, method, options)
24. function hapi.Server.super_.prototype.path (relativeTo)
25. function hapi.Server.super_.prototype.register (plugins)
26. function hapi.Server.super_.prototype.route (options)
27. function hapi.Server.super_.prototype.select ()
28. function hapi.Server.super_.prototype.state (name, options)
29. function hapi.Server.super_.prototype.table (host)
module hapi.Server.super_.super_.prototype
1. function hapi.Server.super_.super_.prototype._emit (criteria, data, generated, callback)
2. function hapi.Server.super_.super_.prototype.addListener (criteria, listener)
3. function hapi.Server.super_.super_.prototype.emit (criteria, data, callback)
4. function hapi.Server.super_.super_.prototype.hasListeners (name)
5. function hapi.Server.super_.super_.prototype.on (criteria, listener)
6. function hapi.Server.super_.super_.prototype.once (criteria, listener)
7. function hapi.Server.super_.super_.prototype.registerEvent (events)
8. function hapi.Server.super_.super_.prototype.registerPodium (podiums)
9. function hapi.Server.super_.super_.prototype.removeAllListeners (name)
10. function hapi.Server.super_.super_.prototype.removeListener (name, listener)
module hapi.auth
1. function hapi.auth (connection)
2. function hapi.auth.access (request, route)
3. function hapi.auth.authenticate (request, next)
4. function hapi.auth.payload (request, next)
5. function hapi.auth.response (request, next)
module hapi.auth.prototype
1. function hapi.auth.prototype._authenticate (request, next)
2. function hapi.auth.prototype._setupRoute (options, path)
3. function hapi.auth.prototype.default (options)
4. function hapi.auth.prototype.lookup (route)
5. function hapi.auth.prototype.scheme (name, scheme)
6. function hapi.auth.prototype.strategy (name, scheme)
7. function hapi.auth.prototype.test (name, request, next)
module hapi.compression
1. function hapi.compression ()
module hapi.compression.prototype
1. function hapi.compression.prototype.accept (request)
2. function hapi.compression.prototype.addDecoder (encoding, decoder)
3. function hapi.compression.prototype.addEncoder (encoding, encoder)
4. function hapi.compression.prototype.encoder (request, encoding)
5. function hapi.compression.prototype.encoding (response)
module hapi.connection
1. function hapi.connection (server, options)
2. function hapi.connection.super_ (events)
3. object hapi.connection._events
module hapi.connection.prototype
1. function hapi.connection.prototype._addRoute (config, plugin)
2. function hapi.connection.prototype._defaultRoutes ()
3. function hapi.connection.prototype._dispatch (options)
4. function hapi.connection.prototype._ext (event)
5. function hapi.connection.prototype._init ()
6. function hapi.connection.prototype._route (configs, plugin)
7. function hapi.connection.prototype._start (callback)
8. function hapi.connection.prototype._stop (options, callback)
9. function hapi.connection.prototype.decoder (encoding, decoder)
10. function hapi.connection.prototype.encoder (encoding, encoder)
11. function hapi.connection.prototype.inject (options, callback)
12. function hapi.connection.prototype.lookup (id)
13. function hapi.connection.prototype.match (method, path, host)
14. function hapi.connection.prototype.table (host)
module hapi.cors
1. function hapi.cors.handler (connection)
2. function hapi.cors.headers (response)
3. function hapi.cors.matchOrigin (origin, settings)
4. function hapi.cors.options (route, connection, server)
5. function hapi.cors.route (options)
module hapi.ext
1. function hapi.ext (type, server)
module hapi.ext.prototype
1. function hapi.ext.prototype.add (event)
2. function hapi.ext.prototype.merge (others)
3. function hapi.ext.prototype.subscribe (route)
module hapi.handler
1. function hapi.handler.configure (handler, route)
2. function hapi.handler.defaults (method, handler, server)
3. function hapi.handler.execute (request, next)
4. function hapi.handler.prerequisitesConfig (config, server)
module hapi.methods
1. function hapi.methods (server)
2. object hapi.methods.methodNameRx
module hapi.methods.prototype
1. function hapi.methods.prototype._add (name, method, options, realm)
2. function hapi.methods.prototype._assign (name, method, normalized)
3. function hapi.methods.prototype.add (name, method, options, realm)
module hapi.promises
1. function hapi.promises.wrap (bind, method, args)
module hapi.protect
1. function hapi.protect (request)
module hapi.protect.prototype
1. function hapi.protect.prototype._onError (err)
2. function hapi.protect.prototype.enter (func)
3. function hapi.protect.prototype.reset ()
4. function hapi.protect.prototype.run (next, enter)
module hapi.reply
1. function hapi.reply ()
module hapi.reply.prototype
1. function hapi.reply.prototype.decorate (property, method)
2. function hapi.reply.prototype.interface (request, realm, options, next)
module hapi.request
1. function hapi.request ()
module hapi.request.prototype
1. function hapi.request.prototype.decorate (property, method, options)
2. function hapi.request.prototype.request (connection, req, res, options)
module hapi.response
1. function hapi.response (source, request, options)
2. function hapi.response.Payload (payload, options)
3. function hapi.response.Peek (podium)
4. function hapi.response.super_ (events)
5. function hapi.response.unmodified (request, options)
6. function hapi.response.wrap (result, request)
module hapi.response.prototype
1. function hapi.response.prototype._close ()
2. function hapi.response.prototype._header (key, value, options)
3. function hapi.response.prototype._isPayloadSupported ()
4. function hapi.response.prototype._isRewritable ()
5. function hapi.response.prototype._isTemporary ()
6. function hapi.response.prototype._marshal (next)
7. function hapi.response.prototype._passThrough ()
8. function hapi.response.prototype._permanent (isPermanent)
9. function hapi.response.prototype._prepare (next)
10. function hapi.response.prototype._processPrepare (next)
11. function hapi.response.prototype._rewritable (isRewritable)
12. function hapi.response.prototype._setRewritable (isRewritable)
13. function hapi.response.prototype._setSource (source, variety)
14. function hapi.response.prototype._setTemporary (isTemporary)
15. function hapi.response.prototype._streamify (source, next)
16. function hapi.response.prototype._tap ()
17. function hapi.response.prototype._temporary (isTemporary)
18. function hapi.response.prototype.bytes (bytes)
19. function hapi.response.prototype.charset (charset)
20. function hapi.response.prototype.code (statusCode)
21. function hapi.response.prototype.created (location)
22. function hapi.response.prototype.encoding (encoding)
23. function hapi.response.prototype.etag (tag, options)
24. function hapi.response.prototype.header (key, value, options)
25. function hapi.response.prototype.location (uri)
26. function hapi.response.prototype.message (httpMessage)
27. function hapi.response.prototype.passThrough (enabled)
28. function hapi.response.prototype.redirect (location)
29. function hapi.response.prototype.replacer (method)
30. function hapi.response.prototype.spaces (count)
31. function hapi.response.prototype.state (name, value, options)
32. function hapi.response.prototype.suffix (suffix)
33. function hapi.response.prototype.takeover ()
34. function hapi.response.prototype.ttl (ttl)
35. function hapi.response.prototype.type (type)
36. function hapi.response.prototype.unstate (name, options)
37. function hapi.response.prototype.vary (value)
module hapi.route
1. function hapi.route (route, connection, plugin, options)
module hapi.route.prototype
1. function hapi.route.prototype._combineExtensions (type, subscribe)
2. function hapi.route.prototype.rebuild (event)
module hapi.schema
1. function hapi.schema.apply (type, options, message)
module hapi.transmit
1. function hapi.transmit.send (request, callback)
module hapi.validation
1. function hapi.validation.compile (rule)
2. function hapi.validation.headers (request, next)
3. function hapi.validation.params (request, next)
4. function hapi.validation.payload (request, next)
5. function hapi.validation.query (request, next)
6. function hapi.validation.response (request, next)

module hapi

function hapi.Server (options)

description and source-code

Server = function (options) {

    Hoek.assert(this instanceof internals.Server, 'Server must be instantiated using new');

    options = Schema.apply('server', options || {});

    this._settings = Hoek.applyToDefaultsWithShallow(Defaults.server, options, ['connections.routes.bind']);
    this._settings.connections = Hoek.applyToDefaultsWithShallow(Defaults.connection, this._settings.connections || {}, ['routes
.bind']);
    this._settings.connections.routes.cors = Hoek.applyToDefaults(Defaults.cors, this._settings.connections.routes.cors);
    this._settings.connections.routes.security = Hoek.applyToDefaults(Defaults.security, this._settings.connections.routes.security
);

    this._caches = {};                                                              // Cache clients
    this._handlers = {};                                                            // Registered handlers
    this._methods = new Methods(this);                                              // Server methods

    this._events = new Podium([{ name: 'log', tags: true }, 'start', 'stop']);      // Server-only events
    this._dependencies = [];                                                        // Plugin dependencies
    this._registrations = {};                                                       // Tracks plugins registered before connection
 added
    this._heavy = new Heavy(this._settings.load);
    this._mime = new Mimos(this._settings.mime);
    this._replier = new Reply();
    this._requestor = new Request();
    this._decorations = {};
    this._plugins = {};                                                             // Exposed plugin properties by name
    this._app = {};
    this._registring = false;                                                       // true while register() is waiting for plugin
 callbacks
    this._state = 'stopped';                                                        // 'stopped', 'initializing', 'initialized', '
starting', 'started', 'stopping', 'invalid'

    this._extensionsSeq = 0;                                                        // Used to keep absolute order of extensions
 based on the order added across locations
    this._extensions = {
        onPreStart: new Ext('onPreStart', this),
        onPostStart: new Ext('onPostStart', this),
        onPreStop: new Ext('onPreStop', this),
        onPostStop: new Ext('onPostStop', this)
    };

    if (options.cache) {
        this._createCache(options.cache);
    }

    if (!this._caches._default) {
        this._createCache([{ engine: CatboxMemory }]);                              // Defaults to memory-based
    }

    Plugin.call(this, this, [], '', null);

    // Subscribe to server log events

    if (this._settings.debug) {
        const debug = (request, event) => {

            const data = event.data;
            console.error('Debug:', event.tags.join(', '), (data ? '\n    ' + (data.stack || (typeof data === 'object' ? Hoek.stringify
(data) : data)) : ''));
        };

        if (this._settings.debug.log) {
            this._events.on({ name: 'log', filter: this._settings.debug.log }, (event) => debug(null, event));
        }

        if (this._settings.debug.request) {
            this.on({ name: 'request', filter: this._settings.debug.request }, debug);
            this.on({ name: 'request-internal', filter: this._settings.debug.request }, debug);
        }
    }
}

example usage
```
n/a
```

function hapi.Server.super_ (server, connections, env, parent)

description and source-code

Server.super_ = function (server, connections, env, parent) {         // env can be a realm or plugin name

    Podium.call(this, [connections && connections.length ? connections : Connection._events, server._events]);

    this._parent = parent;

    // Public interface

    this.root = server;
    this.app = this.root._app;
    this.connections = connections;
    this.load = this.root._heavy.load;
    this.methods = this.root._methods.methods;
    this.mime = this.root._mime;
    this.plugins = this.root._plugins;
    this.settings = this.root._settings;
    this.version = Package.version;

    this.realm = typeof env !== 'string' ? env : {
        _extensions: {
            onPreAuth: new Ext('onPreAuth', this.root),
            onPostAuth: new Ext('onPostAuth', this.root),
            onPreHandler: new Ext('onPreHandler', this.root),
            onPostHandler: new Ext('onPostHandler', this.root),
            onPreResponse: new Ext('onPreResponse', this.root)
        },
        modifiers: {
            route: {}
        },
        plugin: env,
        pluginOptions: {},
        plugins: {},
        settings: {
            bind: undefined,
            files: {
                relativeTo: undefined
            }
        }
    };

    this.auth = {
        default: (opts) => this._applyChild('auth.default', 'auth', 'default', [opts]),
        scheme: (name, scheme) => this._applyChild('auth.scheme', 'auth', 'scheme', [name, scheme]),
        strategy: (name, scheme, mode, opts) => this._applyChild('auth.strategy', 'auth', 'strategy', [name, scheme, mode, opts]),
        test: (name, request, next) => request.connection.auth.test(name, request, next)
    };

    this.cache.provision = (opts, callback) => {

        if (!callback) {
            return Promises.wrap(null, this.cache.provision, [opts]);
        }

        return this.root._createCache(opts, callback);
    };

    this._single();

    // Decorations

    const methods = Object.keys(this.root._decorations);
    for (let i = 0; i < methods.length; ++i) {
        const method = methods[i];
        this[method] = this.root._decorations[method];
    }
}

example usage
```
n/a
```

function hapi.auth (connection)

description and source-code

auth = function (connection) {

    this.connection = connection;
    this._schemes = {};
    this._strategies = {};
    this.settings = {
        default: null           // Strategy used as default if route has no auth settings
    };

    this.api = {};
}

example usage
```
n/a
```

function hapi.compression ()

description and source-code

compression = function () {

    this.encodings = ['identity', 'gzip', 'deflate'];
    this._encoders = {
        identity: null,
        gzip: (options) => Zlib.createGzip(options),
        deflate: (options) => Zlib.createDeflate(options)
    };

    this._decoders = {
        gzip: (options) => Zlib.createGunzip(options),
        deflate: (options) => Zlib.createInflate(options)
    };
}

example usage
```
n/a
```

function hapi.connection (server, options)

description and source-code

connection = function (server, options) {

    const now = Date.now();

    Podium.call(this, internals.Connection._events);

    this.settings = options;                                                        // options cloned in server.connection()
    this.server = server;

    // Normalize settings

    this.settings.labels = Hoek.unique(this.settings.labels || []);                 // Remove duplicates
    if (this.settings.port === undefined) {
        this.settings.port = 0;
    }

    this.type = (typeof this.settings.port === 'string' ? 'socket' : 'tcp');
    if (this.type === 'socket') {
        this.settings.port = (this.settings.port.indexOf('/') !== -1 ? Path.resolve(this.settings.port) : this.settings.port.toLowerCase
());
    }

    if (this.settings.autoListen === undefined) {
        this.settings.autoListen = true;
    }

    Hoek.assert(this.settings.autoListen || !this.settings.port, 'Cannot specify port when autoListen is false');
    Hoek.assert(this.settings.autoListen || !this.settings.address, 'Cannot specify address when autoListen is false');

    // Connection facilities

    this._started = false;
    this._connections = {};
    this._onConnection = null;          // Used to remove event listener on stop
    this.registrations = {};            // Tracks plugin for dependency validation { name -> { version } }

    this._extensions = {
        onRequest: new Ext('onRequest', this.server),
        onPreAuth: new Ext('onPreAuth', this.server),
        onPostAuth: new Ext('onPostAuth', this.server),
        onPreHandler: new Ext('onPreHandler', this.server),
        onPostHandler: new Ext('onPostHandler', this.server),
        onPreResponse: new Ext('onPreResponse', this.server)
    };

    this._requestCounter = { value: internals.counter.min, min: internals.counter.min, max: internals.counter.max };
    this._load = server._heavy.policy(this.settings.load);
    this._compression = new Compression();
    this.states = new Statehood.Definitions(this.settings.state);
    this.auth = new Auth(this);
    this._router = new Call.Router(this.settings.router);
    this._defaultRoutes();

    this.plugins = {};                  // Registered plugin APIs by plugin name
    this.app = {};                      // Place for application-specific state without conflicts with hapi, should not be used
by plugins

    // Create listener

    this.listener = this.settings.listener || (this.settings.tls ? Https.createServer(this.settings.tls) : Http.createServer());
    this.listener.on('request', this._dispatch());
    this._init();

    this.listener.on('clientError', (err, socket) => {

        this.server._log(['connection', 'client', 'error'], err);
    });

    // Connection information

    this.info = {
        created: now,
        started: 0,
        host: this.settings.host || Os.hostname() || 'localhost',
        port: this.settings.port,
        protocol: this.type === 'tcp' ? (this.settings.tls ? 'https' : 'http') : this.type,
        id: Os.hostname() + ':' + process.pid + ':' + now.toString(36)
    };

    this.info.uri = (this.settings.uri || (this.info.protocol + ':' + (this.type === 'tcp' ? '//' + this.info.host + (this.info.
port ? ':' + this.info.port : '') : this.info.port)));

    this.on('route', Cors.options);
}

example usage

...

exports = module.exports = internals.Connection = function (server, options) {

const now = Date.now();

Podium.call(this, internals.Connection._events);

this.settings = options;                                                        // options cloned in server.connection()
this.server = server;

// Normalize settings

this.settings.labels = Hoek.unique(this.settings.labels || []);                 // Remove duplicates
if (this.settings.port === undefined) {
    this.settings.port = 0;
...

function hapi.ext (type, server)

description and source-code

ext = function (type, server) {

    this._topo = new Topo();
    this._server = server;
    this._routes = [];

    this.type = type;
    this.nodes = null;
}

example usage
```
n/a
```

function hapi.methods (server)

description and source-code

methods = function (server) {

    this.server = server;
    this.methods = {};
    this._normalized = {};
}

example usage
```
n/a
```

function hapi.protect (request)

description and source-code

protect = function (request) {

    this._error = null;
    this.logger = request;                          // Replaced with server when request completes

    if (!request.server.settings.useDomains) {
        this.domain = null;
        return;
    }

    Domain = Domain || require('domain');

    this.domain = Domain.create();
    this.domain.on('error', (err) => {

        return this._onError(err);
    });
}

example usage
```
n/a
```

function hapi.reply ()

description and source-code

reply = function () {

    this._decorations = null;
}

example usage
```
n/a
```

function hapi.request ()

description and source-code

request = function () {

    this._decorations = null;
}

example usage

...
            req.socket.end();
        }
    });
}

// Create request

const request = this.server._requestor.request(this, req, res, options);

// Check load

const overload = this._load.check();
if (overload) {
    this.server._log(['load'], this.server.load);
    request._reply(overload);
...

function hapi.response (source, request, options)

description and source-code

response = function (source, request, options) {

    Podium.call(this, ['finish', { name: 'peek', spread: true }]);

    options = options || {};

    this.request = request;
    this.statusCode = null;
    this.headers = {};                          // Incomplete as some headers are stored in flags
    this.variety = null;
    this.source = null;
    this.app = {};
    this.plugins = {};
    this.send = null;                           // Set by reply()
    this.hold = null;                           // Set by reply()

    this.settings = {
        encoding: 'utf8',
        charset: 'utf-8',                       // '-' required by IANA
        ttl: null,
        stringify: null,                        // JSON.stringify options
        passThrough: true,
        varyEtag: false,
        message: null
    };

    this._payload = null;                       // Readable stream
    this._takeover = false;
    this._contentEncoding = null;               // Set during transmit
    this._contentType = null;                   // Used if no explicit content-type is set and type is known
    this._error = null;                         // The boom object when created from an error

    this._processors = {
        marshal: options.marshal,
        prepare: options.prepare,
        close: options.close
    };

    this._setSource(source, options.variety);
}

example usage

...
if (!strategy.methods.response) {
    return next();
}

request._protect.run(next, (exit) => {

    const reply = request.server._replier.interface(request, strategy.realm, {}, exit);
    strategy.methods.response(request, reply);
});
};


internals.Authenticator = class {
constructor(config, request, manager) {
...

function hapi.route (route, connection, plugin, options)

description and source-code

route = function (route, connection, plugin, options) {

    options = options || {};

    // Apply plugin environment (before schema validation)

    const realm = plugin.realm;
    if (realm.modifiers.route.vhost ||
        realm.modifiers.route.prefix) {

        route = Hoek.cloneWithShallow(route, ['config']);       // config is left unchanged
        route.path = (realm.modifiers.route.prefix ? realm.modifiers.route.prefix + (route.path !== '/' ? route.path : '') : route
.path);
        route.vhost = realm.modifiers.route.vhost || route.vhost;
    }

    // Setup and validate route configuration

    Hoek.assert(route.path, 'Route missing path');
    const routeDisplay = route.method + ' ' + route.path;

    let config = route.config;
    if (typeof config === 'function') {
        config = config.call(realm.settings.bind, connection.server);
    }

    Hoek.assert(route.handler || (config && config.handler), 'Missing or undefined handler:', routeDisplay);
    Hoek.assert(!!route.handler ^ !!(config && config.handler), 'Handler must only appear once:', routeDisplay);            // XOR
    Hoek.assert(route.path === '/' || route.path[route.path.length - 1] !== '/' || !connection.settings.router.stripTrailingSlash
, 'Path cannot end with a trailing slash when connection configured to strip:', routeDisplay);

    route = Schema.apply('route', route, routeDisplay);

    const handler = route.handler || config.handler;
    const method = route.method.toLowerCase();
    Hoek.assert(method !== 'head', 'Method name not allowed:', routeDisplay);

    // Apply settings in order: {connection} <- {handler} <- {realm} <- {route}

    const handlerDefaults = Handler.defaults(method, handler, connection.server);
    let base = Hoek.applyToDefaultsWithShallow(connection.settings.routes, handlerDefaults, ['bind']);
    base = Hoek.applyToDefaultsWithShallow(base, realm.settings, ['bind']);
    this.settings = Hoek.applyToDefaultsWithShallow(base, config || {}, ['bind', 'validate.headers', 'validate.payload', 'validate
.params', 'validate.query']);
    this.settings.handler = handler;
    this.settings = Schema.apply('routeConfig', this.settings, routeDisplay);

    const socketTimeout = (this.settings.timeout.socket === undefined ? 2 * 60 * 1000 : this.settings.timeout.socket);
    Hoek.assert(!this.settings.timeout.server || !socketTimeout || this.settings.timeout.server < socketTimeout, 'Server timeout
 must be shorter than socket timeout:', routeDisplay);
    Hoek.assert(!this.settings.payload.timeout || !socketTimeout || this.settings.payload.timeout < socketTimeout, 'Payload timeout
 must be shorter than socket timeout:', routeDisplay);

    this.connection = connection;
    this.server = connection.server;
    this.path = route.path;
    this.method = method;
    this.plugin = plugin;

    this.settings.vhost = route.vhost;
    this.settings.plugins = this.settings.plugins || {};            // Route-specific plugins settings, namespaced using plugin
name
    this.settings.app = this.settings.app || {};                    // Route-specific application settings

    // Path parsing

    this._special = !!options.special;
    this._analysis = this.connection._router.analyze(this.path);
    this.params = this._analysis.params;
    this.fingerprint = this._analysis.fingerprint;

    this.public = {
        method: this.method,
        path: this.path,
        vhost: this.vhost,
        realm: this.plugin.realm,
        settings: this.settings,
        fingerprint: this.fingerprint,
        auth: {
            access: (request) => Auth.access(request, this.public)
        }
    };

    // Validation

    const validation = this.settings.validate;
    if (this.method === 'get') {

        // Assert on config, not on merged settings

        Hoek.assert(!config || !config.payload, 'Cannot set payload settings on HEAD or GET request:', routeDisplay);
        Hoek.assert(!config || !config.validate || !config.validate.payload, 'Cannot validate HEAD or GET requests:', routeDisplay
);

        validation.payload = null;
    }

    ['headers', ' ...

example usage

...

internals.Connection.prototype.match = function (method, path, host) {

    Hoek.assert(method && typeof method === 'string', 'Invalid method:', method);
    Hoek.assert(path && typeof path === 'string' && path[0] === '/', 'Invalid path:&#
x27;, path);
    Hoek.assert(!host || typeof host === 'string', 'Invalid host:', host);

    const match = this._router.route(method.toLowerCase(), path, host);
    Hoek.assert(match !== this._router.specials.badRequest, 'Invalid path:', path);
    if (match === this._router.specials.notFound) {
        return null;
    }

    return match.route.public;
};
...

module hapi.Server

function hapi.Server (options)

description and source-code

Server = function (options) {

    Hoek.assert(this instanceof internals.Server, 'Server must be instantiated using new');

    options = Schema.apply('server', options || {});

    this._settings = Hoek.applyToDefaultsWithShallow(Defaults.server, options, ['connections.routes.bind']);
    this._settings.connections = Hoek.applyToDefaultsWithShallow(Defaults.connection, this._settings.connections || {}, ['routes
.bind']);
    this._settings.connections.routes.cors = Hoek.applyToDefaults(Defaults.cors, this._settings.connections.routes.cors);
    this._settings.connections.routes.security = Hoek.applyToDefaults(Defaults.security, this._settings.connections.routes.security
);

    this._caches = {};                                                              // Cache clients
    this._handlers = {};                                                            // Registered handlers
    this._methods = new Methods(this);                                              // Server methods

    this._events = new Podium([{ name: 'log', tags: true }, 'start', 'stop']);      // Server-only events
    this._dependencies = [];                                                        // Plugin dependencies
    this._registrations = {};                                                       // Tracks plugins registered before connection
 added
    this._heavy = new Heavy(this._settings.load);
    this._mime = new Mimos(this._settings.mime);
    this._replier = new Reply();
    this._requestor = new Request();
    this._decorations = {};
    this._plugins = {};                                                             // Exposed plugin properties by name
    this._app = {};
    this._registring = false;                                                       // true while register() is waiting for plugin
 callbacks
    this._state = 'stopped';                                                        // 'stopped', 'initializing', 'initialized', '
starting', 'started', 'stopping', 'invalid'

    this._extensionsSeq = 0;                                                        // Used to keep absolute order of extensions
 based on the order added across locations
    this._extensions = {
        onPreStart: new Ext('onPreStart', this),
        onPostStart: new Ext('onPostStart', this),
        onPreStop: new Ext('onPreStop', this),
        onPostStop: new Ext('onPostStop', this)
    };

    if (options.cache) {
        this._createCache(options.cache);
    }

    if (!this._caches._default) {
        this._createCache([{ engine: CatboxMemory }]);                              // Defaults to memory-based
    }

    Plugin.call(this, this, [], '', null);

    // Subscribe to server log events

    if (this._settings.debug) {
        const debug = (request, event) => {

            const data = event.data;
            console.error('Debug:', event.tags.join(', '), (data ? '\n    ' + (data.stack || (typeof data === 'object' ? Hoek.stringify
(data) : data)) : ''));
        };

        if (this._settings.debug.log) {
            this._events.on({ name: 'log', filter: this._settings.debug.log }, (event) => debug(null, event));
        }

        if (this._settings.debug.request) {
            this.on({ name: 'request', filter: this._settings.debug.request }, debug);
            this.on({ name: 'request-internal', filter: this._settings.debug.request }, debug);
        }
    }
}

example usage
```
n/a
```

function hapi.Server.super_ (server, connections, env, parent)

description and source-code

super_ = function (server, connections, env, parent) {         // env can be a realm or plugin name

    Podium.call(this, [connections && connections.length ? connections : Connection._events, server._events]);

    this._parent = parent;

    // Public interface

    this.root = server;
    this.app = this.root._app;
    this.connections = connections;
    this.load = this.root._heavy.load;
    this.methods = this.root._methods.methods;
    this.mime = this.root._mime;
    this.plugins = this.root._plugins;
    this.settings = this.root._settings;
    this.version = Package.version;

    this.realm = typeof env !== 'string' ? env : {
        _extensions: {
            onPreAuth: new Ext('onPreAuth', this.root),
            onPostAuth: new Ext('onPostAuth', this.root),
            onPreHandler: new Ext('onPreHandler', this.root),
            onPostHandler: new Ext('onPostHandler', this.root),
            onPreResponse: new Ext('onPreResponse', this.root)
        },
        modifiers: {
            route: {}
        },
        plugin: env,
        pluginOptions: {},
        plugins: {},
        settings: {
            bind: undefined,
            files: {
                relativeTo: undefined
            }
        }
    };

    this.auth = {
        default: (opts) => this._applyChild('auth.default', 'auth', 'default', [opts]),
        scheme: (name, scheme) => this._applyChild('auth.scheme', 'auth', 'scheme', [name, scheme]),
        strategy: (name, scheme, mode, opts) => this._applyChild('auth.strategy', 'auth', 'strategy', [name, scheme, mode, opts]),
        test: (name, request, next) => request.connection.auth.test(name, request, next)
    };

    this.cache.provision = (opts, callback) => {

        if (!callback) {
            return Promises.wrap(null, this.cache.provision, [opts]);
        }

        return this.root._createCache(opts, callback);
    };

    this._single();

    // Decorations

    const methods = Object.keys(this.root._decorations);
    for (let i = 0; i < methods.length; ++i) {
        const method = methods[i];
        this[method] = this.root._decorations[method];
    }
}

example usage
```
n/a
```

module hapi.Server.prototype

function hapi.Server.prototype._createCache (options, _callback)

description and source-code

_createCache = function (options, _callback) {

    Hoek.assert(this._state !== 'initializing', 'Cannot provision server cache while server is initializing');

    options = Schema.apply('cache', options);

    const added = [];
    for (let i = 0; i < options.length; ++i) {
        let config = options[i];
        if (typeof config === 'function') {
            config = { engine: config };
        }

        const name = config.name || '_default';
        Hoek.assert(!this._caches[name], 'Cannot configure the same cache more than once: ', name === '_default' ? 'default cache
' : name);

        let client = null;
        if (typeof config.engine === 'object') {
            client = new Catbox.Client(config.engine);
        }
        else {
            const settings = Hoek.clone(config);
            settings.partition = settings.partition || 'hapi-cache';
            delete settings.name;
            delete settings.engine;
            delete settings.shared;

            client = new Catbox.Client(config.engine, settings);
        }

        this._caches[name] = {
            client,
            segments: {},
            shared: config.shared || false
        };

        added.push(client);
    }

    if (!_callback) {
        return;
    }

    // Start cache

    if (['initialized', 'starting', 'started'].indexOf(this._state) !== -1) {
        const each = (client, next) => client.start(next);
        return Items.parallel(added, each, _callback);
    }

    return Hoek.nextTick(_callback)();
}

example usage
```
n/a
```

function hapi.Server.prototype._invoke (type, next)

description and source-code

_invoke = function (type, next) {

    const exts = this._extensions[type];
    if (!exts.nodes) {
        return next();
    }

    Items.serial(exts.nodes, (ext, nextExt) => {

        const bind = (ext.bind || ext.plugin.realm.settings.bind);
        ext.func.call(bind, ext.plugin._select(), nextExt);
    }, next);
}

example usage

...

    // Execute onRequest extensions (can change request method and url)

    if (!this.connection._extensions.onRequest.nodes) {
        return this._lifecycle();
    }

    this._invoke(this.connection._extensions.onRequest, (err) => {

        return this._lifecycle(err);
    });
};


internals.Request.prototype._lifecycle = function (err) {
...

function hapi.Server.prototype._start (callback)

description and source-code

_start = function (callback) {

    this._state = 'starting';

    const each = (connection, next) => connection._start(next);
    Items.parallel(this.connections, each, (err) => {

        if (err) {
            this._state = 'invalid';
            return Hoek.nextTick(callback)(err);
        }

        this._events.emit('start', null, () => {

            this._invoke('onPostStart', (err) => {

                if (err) {
                    this._state = 'invalid';
                    return callback(err);
                }

                this._state = 'started';
                return callback();
            });
        });
    });
}

example usage
```
n/a
```

function hapi.Server.prototype._validateDeps ()

description and source-code

_validateDeps = function () {

    for (let i = 0; i < this._dependencies.length; ++i) {
        const dependency = this._dependencies[i];
        if (dependency.connections) {
            for (let j = 0; j < dependency.connections.length; ++j) {
                const connection = dependency.connections[j];
                for (let k = 0; k < dependency.deps.length; ++k) {
                    const dep = dependency.deps[k];
                    if (!connection.registrations[dep]) {
                        return new Error('Plugin ' + dependency.plugin + ' missing dependency ' + dep + ' in connection: ' + connection
.info.uri);
                    }
                }
            }
        }
        else {
            for (let j = 0; j < dependency.deps.length; ++j) {
                const dep = dependency.deps[j];
                if (!this._registrations[dep]) {
                    return new Error('Plugin ' + dependency.plugin + ' missing dependency ' + dep);
                }
            }
        }
    }

    return null;
}

example usage
```
n/a
```

function hapi.Server.prototype.connection (options)

description and source-code

connection = function (options) {

    const root = this.root;                                     // Explicitly use the root reference (for plugin invocation)

    const connections = [];
    [].concat(options).forEach((item) => {

        let settings = Hoek.applyToDefaultsWithShallow(root._settings.connections, item || {}, ['listener', 'routes.bind']);
        settings.routes.cors = Hoek.applyToDefaults(root._settings.connections.routes.cors || Defaults.cors, settings.routes.cors
) || false;
        settings.routes.security = Hoek.applyToDefaults(root._settings.connections.routes.security || Defaults.security, settings
.routes.security);

        settings = Schema.apply('connection', settings);        // Applies validation changes (type cast)

        const connection = new Connection(root, settings);
        root.connections.push(connection);
        root.registerPodium(connection);
        root._single();

        const registrations = Object.keys(root._registrations);
        for (let i = 0; i < registrations.length; ++i) {
            const name = registrations[i];
            connection.registrations[name] = root._registrations[name];
        }

        connections.push(connection);
    });

    return this._clone(connections);                            // Use this for active realm
}

example usage

...

exports = module.exports = internals.Connection = function (server, options) {

const now = Date.now();

Podium.call(this, internals.Connection._events);

this.settings = options;                                                        // options cloned in server.connection()
this.server = server;

// Normalize settings

this.settings.labels = Hoek.unique(this.settings.labels || []);                 // Remove duplicates
if (this.settings.port === undefined) {
    this.settings.port = 0;
...

function hapi.Server.prototype.initialize (callback)

description and source-code

initialize = function (callback) {

    if (!callback) {
        return Promises.wrap(this, this.initialize);
    }

    Hoek.assert(typeof callback === 'function', 'Missing required start callback function');
    const nextTickCallback = Hoek.nextTick(callback);

    if (this._registring) {
        return nextTickCallback(new Error('Cannot start server before plugins finished registration'));
    }

    if (this._state === 'initialized') {
        return nextTickCallback();
    }

    if (this._state !== 'stopped') {
        return nextTickCallback(new Error('Cannot initialize server while it is in ' + this._state + ' state'));
    }

    const error = this._validateDeps();
    if (error) {
        return nextTickCallback(error);
    }

    this._state = 'initializing';

    // Start cache

    const caches = Object.keys(this._caches);
    const each = (cache, next) => this._caches[cache].client.start(next);
    Items.parallel(caches, each, (err) => {

        if (err) {
            this._state = 'invalid';
            return callback(err);
        }

        // After hooks

        this._invoke('onPreStart', (err) => {

            if (err) {
                this._state = 'invalid';
                return callback(err);
            }

            // Load measurements

            this._heavy.start();

            // Listen to connections

            this._state = 'initialized';
            return callback();
        });
    });
}

example usage
```
n/a
```

function hapi.Server.prototype.start (callback)

description and source-code

start = function (callback) {

    if (!callback) {
        return Promises.wrap(this, this.start);
    }

    Hoek.assert(typeof callback === 'function', 'Missing required start callback function');
    const nextTickCallback = Hoek.nextTick(callback);

    if (!this.connections.length) {
        return nextTickCallback(new Error('No connections to start'));
    }

    if (this._state === 'initialized' ||
        this._state === 'started') {

        const error = this._validateDeps();
        if (error) {
            return nextTickCallback(error);
        }
    }

    if (this._state === 'initialized') {
        return this._start(callback);
    }

    if (this._state === 'started') {
        const each = (connection, next) => connection._start(next);
        return Items.parallel(this.connections, each, nextTickCallback);
    }

    if (this._state !== 'stopped') {
        return nextTickCallback(new Error('Cannot start server while it is in ' + this._state + ' state'));
    }

    this.initialize((err) => {

        if (err) {
            return callback(err);
        }

        this._start(callback);
    });
}

example usage
```
n/a
```

function hapi.Server.prototype.stop ()

description and source-code

stop = function () {

    const args = arguments.length;
    const lastArg = arguments[args - 1];
    const callback = (!args ? null : (typeof lastArg === 'function' ? lastArg : null));
    const options = (!args ? {} : (args === 1 ? (callback ? {} : arguments[0]) : arguments[0]));

    if (!callback) {
        return Promises.wrap(this, this.stop, [options]);
    }

    options.timeout = options.timeout || 5000;                                              // Default timeout to 5 seconds

    if (['stopped', 'initialized', 'started', 'invalid'].indexOf(this._state) === -1) {
        return Hoek.nextTick(callback)(new Error('Cannot stop server while in ' + this._state + ' state'));
    }

    this._state = 'stopping';

    this._invoke('onPreStop', (err) => {

        if (err) {
            this._state = 'invalid';
            return callback(err);
        }

        const each = (connection, next) => connection._stop(options, next);
        Items.parallel(this.connections, each, (err) => {

            if (err) {
                this._state = 'invalid';
                return callback(err);
            }

            const caches = Object.keys(this._caches);
            for (let i = 0; i < caches.length; ++i) {
                this._caches[caches[i]].client.stop();
            }

            this._events.emit('stop', null, () => {

                this._heavy.stop();
                this._invoke('onPostStop', (err) => {

                    if (err) {
                        this._state = 'invalid';
                        return callback(err);
                    }

                    this._state = 'stopped';
                    return callback();
                });
            });
        });
    });
}

example usage
```
n/a
```

module hapi.Server.super_

function hapi.Server.super_ (events)

description and source-code

super_ = function (events) {

    // Use descriptive names to avoid conflict when inherited

    this._eventListeners = Object.create(null);
    this._notificationsQueue = [];
    this._eventsProcessing = false;
    this._sourcePodiums = [];

    if (events) {
        this.registerEvent(events);
    }
}

example usage
```
n/a
```

module hapi.Server.super_.prototype

function hapi.Server.super_.prototype._apply (type, func, args)

description and source-code

_apply = function (type, func, args) {

    Hoek.assert(this.connections, 'Cannot add ' + type + ' from a connectionless plugin');
    Hoek.assert(this.connections.length, 'Cannot add ' + type + ' without a connection');

    for (let i = 0; i < this.connections.length; ++i) {
        func.apply(this.connections[i], args);
    }
}

example usage
```
n/a
```

function hapi.Server.super_.prototype._applyChild (type, child, func, args)

description and source-code

_applyChild = function (type, child, func, args) {

    Hoek.assert(this.connections, 'Cannot add ' + type + ' from a connectionless plugin');
    Hoek.assert(this.connections.length, 'Cannot add ' + type + ' without a connection');

    for (let i = 0; i < this.connections.length; ++i) {
        const obj = this.connections[i][child];
        obj[func].apply(obj, args);
    }
}

example usage
```
n/a
```

function hapi.Server.super_.prototype._clone (connections, plugin)

description and source-code

_clone = function (connections, plugin) {

    const env = (plugin !== undefined ? plugin : this.realm);                     // Allow empty string
    return new internals.Plugin(this.root, connections, env, this);
}

example usage

...

Hoek.assert(name, 'Authentication strategy must have a name');
Hoek.assert(name !== 'bypass', 'Cannot use reserved strategy name: bypass');
Hoek.assert(!this._strategies[name], 'Authentication strategy name already exists');
Hoek.assert(scheme, 'Authentication strategy', name, 'missing scheme');
Hoek.assert(this._schemes[scheme], 'Authentication strategy', name, 'uses unknown scheme:', scheme);

const server = this.connection.server._clone([this.connection], '');
const strategy = this._schemes[scheme](server, options);

Hoek.assert(strategy.authenticate, 'Invalid scheme:', name, 'missing authenticate() method');
Hoek.assert(typeof strategy.authenticate === 'function', 'Invalid scheme:', name, 'invalid authenticate
() method');
Hoek.assert(!strategy.payload || typeof strategy.payload === 'function', 'Invalid scheme:', name, 'invalid
 payload() method');
Hoek.assert(!strategy.response || typeof strategy.response === 'function', 'Invalid scheme:', name, 'invalid
 response() method');
strategy.options = strategy.options || {};
...

function hapi.Server.super_.prototype._ext (event)

description and source-code

_ext = function (event) {

    event = Hoek.shallow(event);
    event.plugin = this;
    const type = event.type;

    if (!this.root._extensions[type]) {

        // Realm route extensions

        if (event.options.sandbox === 'plugin') {
            Hoek.assert(this.realm._extensions[type], 'Unknown event type', type);
            return this.realm._extensions[type].add(event);
        }

        // Connection route extensions

        return this._apply('ext', Connection.prototype._ext, [event]);
    }

    // Server extensions

    Hoek.assert(!event.options.sandbox, 'Cannot specify sandbox option for server extension');
    Hoek.assert(type !== 'onPreStart' || this.root._state === 'stopped', 'Cannot add onPreStart (after) extension after the server
 was initialized');
    this.root._extensions[type].add(event);
}

example usage
```
n/a
```

function hapi.Server.super_.prototype._log (tags, data)

description and source-code

_log = function (tags, data) {

    return this.log(tags, data, null, true);
}

example usage

...

    if (config.mode === 'optional' ||
        config.mode === 'try') {

        request.auth.isAuthenticated = false;
        request.auth.credentials = null;
        request.auth.error = err;
        request._log(['auth', 'unauthenticated']);
        return next();
    }

    return next(err);
}

validate(err, result, next) {                 // err can be Boom, Error, or a valid response object
...

function hapi.Server.super_.prototype._select (labels, plugin)

description and source-code

_select = function (labels, plugin) {

    let connections = this.connections;

    if (labels &&
        labels.length) {            // Captures both empty arrays and empty strings

        Hoek.assert(this.connections, 'Cannot select inside a connectionless plugin');

        connections = [];
        for (let i = 0; i < this.connections.length; ++i) {
            const connection = this.connections[i];
            if (Hoek.intersect(connection.settings.labels, labels).length) {
                connections.push(connection);
            }
        }

        if (!plugin &&
            connections.length === this.connections.length) {

            return this;
        }
    }

    const env = (plugin !== undefined ? plugin : this.realm);                     // Allow empty string
    return new internals.Plugin(this.root, connections, env, this);
}

example usage
```
n/a
```

function hapi.Server.super_.prototype._single ()

description and source-code

_single = function () {

    if (this.connections &&
        this.connections.length === 1) {

        this.info = this.connections[0].info;
        this.listener = this.connections[0].listener;
        this.registrations = this.connections[0].registrations;
        this.auth.api = this.connections[0].auth.api;
    }
    else {
        this.info = null;
        this.listener = null;
        this.registrations = null;
        this.auth.api = null;
    }
}

example usage
```
n/a
```

function hapi.Server.super_.prototype.bind (context)

description and source-code

bind = function (context) {

    Hoek.assert(typeof context === 'object', 'bind must be an object');
    this.realm.settings.bind = context;
}

example usage

...

    Items.serial(request._route._prerequisites, each, (err) => {

        if (err) {
            return callback(err);
        }

        const wrapped = domain ? domain.bind(internals.handler) : internals.handler;
        return wrapped(request, callback);
    });
};


internals.handler = function (request, callback) {
...

function hapi.Server.super_.prototype.cache (options, _segment)

description and source-code

cache = function (options, _segment) {

    options = Schema.apply('cachePolicy', options);

    const segment = options.segment || _segment || (this.realm.plugin ? '!' + this.realm.plugin : '');
    Hoek.assert(segment, 'Missing cache segment name');

    const cacheName = options.cache || '_default';
    const cache = this.root._caches[cacheName];
    Hoek.assert(cache, 'Unknown cache', cacheName);
    Hoek.assert(!cache.segments[segment] || cache.shared || options.shared, 'Cannot provision the same cache segment more than once
');
    cache.segments[segment] = true;

    return new Catbox.Policy(options, cache.client, segment);
}

example usage

...

    settings.cache.generateFunc = (id, next) => {

id.args.push(next);                     // function (err, result, ttl)
normalized.apply(bind, id.args);
    };

    const cache = this.server.cache(settings.cache, '#' + name);

    const func = function (/* arguments, methodNext */) {

const args = [];
for (let i = 0; i < arguments.length - 1; ++i) {
    args.push(arguments[i]);
}
...

function hapi.Server.super_.prototype.decoder (encoding, decoder)

description and source-code

decoder = function (encoding, decoder) {

    this._apply('decoder', Connection.prototype.decoder, [encoding, decoder]);
}

example usage
```
n/a
```

function hapi.Server.super_.prototype.decorate (type, property, method, options)

description and source-code

decorate = function (type, property, method, options) {

    Hoek.assert(['reply', 'request', 'server'].indexOf(type) !== -1, 'Unknown decoration type:', type);
    Hoek.assert(property, 'Missing decoration property name');
    Hoek.assert(typeof property === 'string', 'Decoration property must be a string');
    Hoek.assert(property[0] !== '_', 'Property name cannot begin with an underscore:', property);

    // Request

    if (type === 'request') {
        return this.root._requestor.decorate(property, method, options);
    }

    Hoek.assert(!options, 'Cannot specify options for non-request decoration');

    // Reply

    if (type === 'reply') {
        return this.root._replier.decorate(property, method);
    }

    // Server

    Hoek.assert(!this.root._decorations[property], 'Server decoration already defined:', property);
    Hoek.assert(this[property] === undefined && this.root[property] === undefined, 'Cannot override the built-in server interface
 method:', property);

    this.root._decorations[property] = method;

    this[property] = method;
    let parent = this._parent;
    while (parent) {
        parent[property] = method;
        parent = parent._parent;
    }
}

example usage
```
n/a
```

function hapi.Server.super_.prototype.dependency (dependencies, after)

description and source-code

dependency = function (dependencies, after) {

    Hoek.assert(this.realm.plugin, 'Cannot call dependency() outside of a plugin');
    Hoek.assert(!after || typeof after === 'function', 'Invalid after method');

    dependencies = [].concat(dependencies);
    this.root._dependencies.push({ plugin: this.realm.plugin, connections: this.connections, deps: dependencies });

    if (after) {
        this.ext('onPreStart', after, { after: dependencies });
    }
}

example usage
```
n/a
```

function hapi.Server.super_.prototype.emit (criteria, data, callback)

description and source-code

emit = function (criteria, data, callback) {

    this.root._events.emit(criteria, data, callback);
}

example usage

...
for (let i = 0; i < vhosts.length; ++i) {
    const vhost = vhosts[i];
    const record = this._router.add({ method: route.method, path: route.path, vhost, analysis: route._analysis, id: route.settings
.id }, route);
    route.fingerprint = record.fingerprint;
    route.params = record.params;
}

this.emit('route', [route.public, this, plugin]);
};


internals.Connection.prototype._defaultRoutes = function () {

this._router.special('notFound', new Route({ method: '_special', path: '/{p*}', handler: internals
.notFound }, this, this.server, { special: true }));
this._router.special('badRequest', new Route({ method: '_special', path: '/{p*}', handler: internals
.badRequest }, this, this.server, { special: true }));
...

function hapi.Server.super_.prototype.encoder (encoding, encoder)

description and source-code

encoder = function (encoding, encoder) {

    this._apply('encoder', Connection.prototype.encoder, [encoding, encoder]);
}

example usage

...
length !== 0 &&
response.statusCode !== 206 &&
response._isPayloadSupported()) {

delete response.headers['content-length'];
response._header('content-encoding', encoding);

compressor = request.connection._compression.encoder(request, encoding);
    }

    if ((response.headers['content-encoding'] || encoding) &&
response.headers.etag &&
response.settings.varyEtag) {

response.headers.etag = response.headers.etag.slice(0, -1) + '-' + (response.headers['content-encoding'] ||
encoding) + '"';
...

function hapi.Server.super_.prototype.event (event)

description and source-code

event = function (event) {

    this.root._events.registerEvent(event);
}

example usage
```
n/a
```

function hapi.Server.super_.prototype.expose (key, value)

description and source-code

expose = function (key, value) {

    Hoek.assert(this.realm.plugin, 'Cannot call expose() outside of a plugin');

    const plugin = this.realm.plugin;
    this.root.plugins[plugin] = this.root.plugins[plugin] || {};

    if (typeof key === 'string') {
        this.root.plugins[plugin][key] = value;
    }
    else {
        Hoek.merge(this.root.plugins[plugin], key);
    }
}

example usage
```
n/a
```

function hapi.Server.super_.prototype.ext (events)

description and source-code

ext = function (events) {        // (event, method, options) -OR- (events)

    if (typeof events === 'string') {
        events = { type: arguments[0], method: arguments[1], options: arguments[2] };
    }

    events = Schema.apply('exts', events);

    for (let i = 0; i < events.length; ++i) {
        this._ext(events[i]);
    }
}

example usage
```
n/a
```

function hapi.Server.super_.prototype.handler (name, method)

description and source-code

handler = function (name, method) {

    Hoek.assert(typeof name === 'string', 'Invalid handler name');
    Hoek.assert(!this.root._handlers[name], 'Handler name already exists:', name);
    Hoek.assert(typeof method === 'function', 'Handler must be a function:', name);
    Hoek.assert(!method.defaults || typeof method.defaults === 'object' || typeof method.defaults === 'function', 'Handler defaults
 property must be an object or function');
    this.root._handlers[name] = method;
}

example usage

...

internals.Connection.prototype._defaultRoutes = function () {

this._router.special('notFound', new Route({ method: '_special', path: '/{p*}', handler: internals
.notFound }, this, this.server, { special: true }));
this._router.special('badRequest', new Route({ method: '_special', path: '/{p*}', handler: internals
.badRequest }, this, this.server, { special: true }));

if (this.settings.routes.cors) {
    Cors.handler(this);
}
};


internals.notFound = function (request, reply) {

return reply(Boom.notFound());
...

function hapi.Server.super_.prototype.inject (options, callback)

description and source-code

inject = function (options, callback) {

    Hoek.assert(this.connections.length === 1, 'Method not available when the selection has more than one connection or none');
    return this.connections[0].inject(options, callback);
}

example usage

...
};
};


internals.Connection.prototype.inject = function (options, callback) {

if (!callback) {
    return new Promise((resolve, reject) => this.inject(options, (res) => resolve
(res)));
}

let settings = options;
if (typeof settings === 'string') {
    settings = { url: settings };
}
...

function hapi.Server.super_.prototype.log (tags, data, timestamp, _internal)

description and source-code

log = function (tags, data, timestamp, _internal) {

    tags = [].concat(tags);
    timestamp = (timestamp ? (timestamp instanceof Date ? timestamp.getTime() : timestamp) : Date.now());
    const internal = !!_internal;

    const update = (typeof data !== 'function' ? { timestamp, tags, data, internal } : () => {

        return { timestamp, tags, data: data(), internal };
    });

    this.root._events.emit({ name: 'log', tags }, update);
}

example usage

...

this.connection.emit({ name: internal ? 'request-internal' : 'request', tags }, update);
};


internals.Request.prototype._log = function (tags, data) {

return this.log(tags, data, null, true);
};


internals.Request.prototype.getLog = function (tags, internal) {

Hoek.assert(this.route.settings.log, 'Request logging is disabled');
...

function hapi.Server.super_.prototype.lookup (id)

description and source-code

lookup = function (id) {

    Hoek.assert(this.connections.length === 1, 'Method not available when the selection has more than one connection or none');
    return this.connections[0].lookup(id);
}

example usage

...
return auth._authenticate(request, next);
};


internals.Auth.access = function (request, route) {

const auth = request.connection.auth;
const config = auth.lookup(route);
if (!config) {
    return true;
}

const credentials = request.auth.credentials;
if (!credentials) {
    return false;
...

function hapi.Server.super_.prototype.match (method, path, host)

description and source-code

match = function (method, path, host) {

    Hoek.assert(this.connections.length === 1, 'Method not available when the selection has more than one connection or none');
    return this.connections[0].match(method, path, host);
}

example usage

...
const method = request.headers['access-control-request-method'];
if (!method) {
    return reply(Boom.notFound('CORS error: Missing Access-Control-Request-Method header'));
}

// Lookup route

const route = request.connection.match(method, request.path, request.info.hostname);
if (!route) {
    return reply(Boom.notFound());
}

const settings = route.settings.cors;
if (!settings) {
    return reply({ message: 'CORS is disabled for this route' });
...

function hapi.Server.super_.prototype.method (name, method, options)

description and source-code

method = function (name, method, options) {

    return this.root._methods.add(name, method, options, this.realm);
}

example usage

...
    // Decorate

    if (this._decorations) {
        const properties = Object.keys(this._decorations);
        for (let i = 0; i < properties.length; ++i) {
            const property = properties[i];
            const assignment = this._decorations[property];
            request[property] = (assignment.apply ? assignment.method(request) : assignment
.method);
        }
    }

    return request;
};
...

function hapi.Server.super_.prototype.path (relativeTo)

description and source-code

path = function (relativeTo) {

    Hoek.assert(relativeTo && typeof relativeTo === 'string', 'relativeTo must be a non-empty string');
    this.realm.settings.files.relativeTo = relativeTo;
}

example usage
```
n/a
```

function hapi.Server.super_.prototype.register (plugins)

description and source-code

register = function (plugins) {

    let options = (typeof arguments[1] === 'object' ? arguments[1] : {});
    const callback = (typeof arguments[1] === 'object' ? arguments[2] : arguments[1]);

    if (!callback) {
        return Promises.wrap(this, this.register, [plugins, options]);
    }

    if (this.realm.modifiers.route.prefix ||
        this.realm.modifiers.route.vhost) {

        options = Hoek.clone(options);
        options.routes = options.routes || {};

        options.routes.prefix = (this.realm.modifiers.route.prefix || '') + (options.routes.prefix || '') || undefined;
        options.routes.vhost = this.realm.modifiers.route.vhost || options.routes.vhost;
    }

    options = Schema.apply('register', options);

    /*
        const register = function (server, options, next) { return next(); };
        register.attributes = {
            pkg: require('../package.json'),
            name: 'plugin',
            version: '1.1.1',
            multiple: false,
            dependencies: [],
            connections: false,
            once: true
        };

        const item = {
            register: register,
            options: options        // -optional--
        };

        - OR -

        const item = function () {}
        item.register = register;
        item.options = options;

        const plugins = register, items, [register, item]
    */

    const registrations = [];
    plugins = [].concat(plugins);
    for (let i = 0; i < plugins.length; ++i) {
        let plugin = plugins[i];

        if (typeof plugin === 'function') {
            if (!plugin.register) {                                 // plugin is register() function
                plugin = { register: plugin };
            }
            else {
                plugin = Hoek.shallow(plugin);                      // Convert function to object
            }
        }

        if (plugin.register.register) {                             // Required plugin
            plugin.register = plugin.register.register;
        }

        plugin = Schema.apply('plugin', plugin);

        const attributes = plugin.register.attributes;
        const registration = {
            register: plugin.register,
            name: attributes.name || attributes.pkg.name,
            version: attributes.version || attributes.pkg.version,
            multiple: attributes.multiple,
            pluginOptions: plugin.options,
            dependencies: attributes.dependencies,
            connections: attributes.connections,
            options: {
                once: attributes.once || (plugin.once !== undefined ? plugin.once : options.once),
                routes: {
                    prefix: plugin.routes.prefix || options.routes.prefix,
                    vhost: plugin.routes.vhost || options.routes.vhost
                },
                select: plugin.select || options.select
            }
        };

        registrations.push(registration);
    }

    this.root._registring = true;

    const each = (item, next) => {

        const selection = this._select(item.options.select, item.name);
        selection.realm.modifiers.route.prefix = item.options.routes.prefix;
        selection.realm.modifiers.route.vhost = item.options.routes.vhost;
        selection.realm.pluginOptions = item.pluginOptions || {};

        const registrationData = {
            version: item.version,
            name: item.name,
            options: item.pluginOptions,
            attributes: item.register.attributes
        };

        // Protect against multiple registrations

        const connectionless = (item.connections === 'conditional' ? selection.connections.length === 0 : !item.connections);
        if (connectionless) {
            if (this.root._registrations[item.name]) {
                if (item.options.once) {
                    return next();
                }

                Hoek.assert(item.multiple, 'Plugin', item.name, 'already registered');
            }
            else {
                this.root._registrations[item.name] = registrationData; ...

example usage
```
n/a
```

function hapi.Server.super_.prototype.route (options)

description and source-code

route = function (options) {

    Hoek.assert(arguments.length === 1, 'Method requires a single object argument or a single array of objects');
    Hoek.assert(typeof options === 'object', 'Invalid route options');
    Hoek.assert(this.connections, 'Cannot add route from a connectionless plugin');
    Hoek.assert(this.connections.length, 'Cannot add a route without any connections');

    this._apply('route', Connection.prototype._route, [options, this]);
}

example usage

...

internals.Connection.prototype.match = function (method, path, host) {

    Hoek.assert(method && typeof method === 'string', 'Invalid method:', method);
    Hoek.assert(path && typeof path === 'string' && path[0] === '/', 'Invalid path:&#
x27;, path);
    Hoek.assert(!host || typeof host === 'string', 'Invalid host:', host);

    const match = this._router.route(method.toLowerCase(), path, host);
    Hoek.assert(match !== this._router.specials.badRequest, 'Invalid path:', path);
    if (match === this._router.specials.notFound) {
        return null;
    }

    return match.route.public;
};
...

function hapi.Server.super_.prototype.select ()

description and source-code

select = function () {

    let labels = [];
    for (let i = 0; i < arguments.length; ++i) {
        labels.push(arguments[i]);
    }

    labels = Hoek.flatten(labels);
    return this._select(labels);
}

example usage
```
n/a
```

function hapi.Server.super_.prototype.state (name, options)

description and source-code

state = function (name, options) {

    this._applyChild('state', 'states', 'add', [name, options]);
}

example usage

...
    const response = request.response;

    Cors.headers(response);
    internals.content(response, false);
    internals.security(response);
    internals.unmodified(response);

    internals.state(response, (err) => {

if (err) {
    request._log(['state', 'response', 'error'], err);
    request._states = {};                                           // Clear broken state
    return next(err);
}
...

function hapi.Server.super_.prototype.table (host)

description and source-code

table = function (host) {

    Hoek.assert(this.connections, 'Cannot request routing table from a connectionless plugin');

    const table = [];
    for (let i = 0; i < this.connections.length; ++i) {
        const connection = this.connections[i];
        table.push({ info: connection.info, labels: connection.settings.labels, table: connection.table(host) });
    }

    return table;
}

example usage

...
    return callback(res);
});
};


internals.Connection.prototype.table = function (host) {

return this._router.table(host);
};


internals.Connection.prototype.lookup = function (id) {

Hoek.assert(id && typeof id === 'string', 'Invalid route id:', id);
...

module hapi.Server.super_.super_.prototype

function hapi.Server.super_.super_.prototype._emit (criteria, data, generated, callback)

description and source-code

_emit = function (criteria, data, generated, callback) {

    criteria = internals.criteria(criteria);

    const name = criteria.name;
    Hoek.assert(name, 'Criteria missing event name');

    const event = this._eventListeners[name];
    Hoek.assert(event, `Unknown event ${name}`);
    Hoek.assert(!event.flags.spread || Array.isArray(data) || typeof data === 'function', 'Data must be an array for spread event
');
    Hoek.assert(!criteria.channel || typeof criteria.channel === 'string', 'Invalid channel name');
    Hoek.assert(!criteria.channel || !event.flags.channels || event.flags.channels.indexOf(criteria.channel) !== -1, `Unknown ${
criteria.channel} channel`);

    if (typeof criteria.tags === 'string') {
        criteria.tags = [criteria.tags];
    }

    if (criteria.tags &&
        Array.isArray(criteria.tags)) {

        criteria.tags = Hoek.mapToObject(criteria.tags);
    }

    internals.emit(this, { criteria, data, callback, generated });
}

example usage
```
n/a
```

function hapi.Server.super_.super_.prototype.addListener (criteria, listener)

description and source-code

addListener = function (criteria, listener) {

    criteria = internals.criteria(criteria);
    criteria.listener = listener;

    if (criteria.filter &&
        (typeof criteria.filter === 'string' || Array.isArray(criteria.filter))) {

        criteria.filter = { tags: criteria.filter };
    }

    criteria = Joi.attempt(criteria, internals.schema.listener, 'Invalid event listener options');

    const name = criteria.name;
    const event = this._eventListeners[name];
    Hoek.assert(event, `Unknown event ${name}`);
    Hoek.assert(!criteria.channels || !event.flags.channels || Hoek.intersect(event.flags.channels, criteria.channels).length ===
criteria.channels.length, `Unknown event channels ${criteria.channels && criteria.channels.join(', ')}`);

    this._eventListeners[name].handlers = this._eventListeners[name].handlers || [];
    this._eventListeners[name].handlers.push(criteria);

    return this;
}

example usage
```
n/a
```

function hapi.Server.super_.super_.prototype.emit (criteria, data, callback)

description and source-code

emit = function (criteria, data, callback) {

    return this._emit(criteria, data, false, callback);
}

example usage

...
for (let i = 0; i < vhosts.length; ++i) {
    const vhost = vhosts[i];
    const record = this._router.add({ method: route.method, path: route.path, vhost, analysis: route._analysis, id: route.settings
.id }, route);
    route.fingerprint = record.fingerprint;
    route.params = record.params;
}

this.emit('route', [route.public, this, plugin]);
};


internals.Connection.prototype._defaultRoutes = function () {

this._router.special('notFound', new Route({ method: '_special', path: '/{p*}', handler: internals
.notFound }, this, this.server, { special: true }));
this._router.special('badRequest', new Route({ method: '_special', path: '/{p*}', handler: internals
.badRequest }, this, this.server, { special: true }));
...

function hapi.Server.super_.super_.prototype.hasListeners (name)

description and source-code

hasListeners = function (name) {

    Hoek.assert(this._eventListeners[name], `Unknown event ${name}`);
    return !!this._eventListeners[name].handlers;
}

example usage

...

    this._states[name] = state;
};


internals.Request.prototype._tap = function () {

    return (this.hasListeners('finish') || this.hasListeners('peek'
;) ? new Response.Peek(this) : null);
};


internals.Request.prototype.generateResponse = function (source, options) {

    return new Response(source, this, options);
};
...

function hapi.Server.super_.super_.prototype.on (criteria, listener)

description and source-code

on = function (criteria, listener) {

    criteria = internals.criteria(criteria);
    criteria.listener = listener;

    if (criteria.filter &&
        (typeof criteria.filter === 'string' || Array.isArray(criteria.filter))) {

        criteria.filter = { tags: criteria.filter };
    }

    criteria = Joi.attempt(criteria, internals.schema.listener, 'Invalid event listener options');

    const name = criteria.name;
    const event = this._eventListeners[name];
    Hoek.assert(event, `Unknown event ${name}`);
    Hoek.assert(!criteria.channels || !event.flags.channels || Hoek.intersect(event.flags.channels, criteria.channels).length ===
criteria.channels.length, `Unknown event channels ${criteria.channels && criteria.channels.join(', ')}`);

    this._eventListeners[name].handlers = this._eventListeners[name].handlers || [];
    this._eventListeners[name].handlers.push(criteria);

    return this;
}

example usage

...

this.plugins = {};                  // Registered plugin APIs by plugin name
this.app = {};                      // Place for application-specific state without conflicts with hapi, should not be used by plugins

// Create listener

this.listener = this.settings.listener || (this.settings.tls ? Https.createServer(this.settings.tls) : Http.createServer());
this.listener.on('request', this._dispatch());
this._init();

this.listener.on('clientError', (err, socket) => {

    this.server._log(['connection', 'client', 'error'], err);
});
...

function hapi.Server.super_.super_.prototype.once (criteria, listener)

description and source-code

once = function (criteria, listener) {

    criteria = internals.criteria(criteria);
    return this.on(Object.assign(criteria, { count: 1 }), listener);
}

example usage

...



internals.Connection.prototype._init = function () {

    // Setup listener

    this.listener.once('listening', () => {

// Update the address, port, and uri with active values

if (this.type === 'tcp') {
    const address = this.listener.address();
    this.info.address = address.address;
    this.info.port = address.port;
...

function hapi.Server.super_.super_.prototype.registerEvent (events)

description and source-code

registerEvent = function (events) {

    events = Hoek.flatten([].concat(events));
    events.forEach((event) => {

        if (!event) {
            return;
        }

        if (event instanceof internals.Podium) {
            return this.registerPodium(event);
        }

        if (typeof event === 'string') {
            event = { name: event };
        }

        event = Joi.attempt(event, internals.schema.event, 'Invalid event options');

        const name = event.name;
        if (this._eventListeners[name]) {
            Hoek.assert(event.shared, `Event ${name} exists`);
            return;
        }

        this._eventListeners[name] = { handlers: null, flags: event };
        this._sourcePodiums.forEach((podium) => {

            if (!podium._eventListeners[name]) {
                podium._eventListeners[name] = { handlers: null, flags: event };
            }
        });
    });
}

example usage
```
n/a
```

function hapi.Server.super_.super_.prototype.registerPodium (podiums)

description and source-code

registerPodium = function (podiums) {

    [].concat(podiums).forEach((podium) => {

        if (podium._sourcePodiums.indexOf(this) !== -1) {
            return;
        }

        podium._sourcePodiums.push(this);
        Object.keys(podium._eventListeners).forEach((name) => {

            if (!this._eventListeners[name]) {
                this._eventListeners[name] = { handlers: null, flags: podium._eventListeners[name].flags };
            }
        });
    });
}

example usage
```
n/a
```

function hapi.Server.super_.super_.prototype.removeAllListeners (name)

description and source-code

removeAllListeners = function (name) {

    Hoek.assert(this._eventListeners[name], `Unknown event ${name}`);
    this._eventListeners[name].handlers = null;
    return this;
}

example usage
```
n/a
```

function hapi.Server.super_.super_.prototype.removeListener (name, listener)

description and source-code

removeListener = function (name, listener) {

    Hoek.assert(this._eventListeners[name], `Unknown event ${name}`);
    Hoek.assert(typeof listener === 'function', 'Listener must be a function');

    const handlers = this._eventListeners[name].handlers;
    if (!handlers) {
        return this;
    }

    const filtered = handlers.filter((handler) => handler.listener !== listener);
    this._eventListeners[name].handlers = (filtered.length ? filtered : null);
    return this;
}

example usage

...
    return callback(err);
};

this.listener.once('error', onError);

const finalize = () => {

    this.listener.removeListener('error', onError);
    callback();
};

if (this.type !== 'tcp') {
    this.listener.listen(this.settings.port, finalize);
}
else {
...

module hapi.auth

function hapi.auth (connection)

description and source-code

auth = function (connection) {

    this.connection = connection;
    this._schemes = {};
    this._strategies = {};
    this.settings = {
        default: null           // Strategy used as default if route has no auth settings
    };

    this.api = {};
}

example usage
```
n/a
```

function hapi.auth.access (request, route)

description and source-code

access = function (request, route) {

    const auth = request.connection.auth;
    const config = auth.lookup(route);
    if (!config) {
        return true;
    }

    const credentials = request.auth.credentials;
    if (!credentials) {
        return false;
    }

    return !internals.access(request, config, credentials, 'bypass');
}

example usage

...
}

const credentials = request.auth.credentials;
if (!credentials) {
    return false;
}

return !internals.access(request, config, credentials, 'bypass');
};


internals.Auth.prototype._authenticate = function (request, next) {

const config = this.lookup(request.route);
if (!config) {
...

function hapi.auth.authenticate (request, next)

description and source-code

authenticate = function (request, next) {

    const auth = request.connection.auth;
    return auth._authenticate(request, next);
}

example usage

...
internals.Auth.prototype.test = function (name, request, next) {

Hoek.assert(name, 'Missing authentication strategy name');
const strategy = this._strategies[name];
Hoek.assert(strategy, 'Unknown authentication strategy:', name);

const reply = request.server._replier.interface(request, strategy.realm, { data: true }, (response) => next(response, reply
._data && reply._data.credentials));
strategy.methods.authenticate(request, reply);
};


internals.Auth.prototype._setupRoute = function (options, path) {

if (!options) {
    return options;         // Preserve the difference between undefined and false
...

function hapi.auth.payload (request, next)

description and source-code

payload = function (request, next) {

    if (!request.auth.isAuthenticated ||
        request.auth.strategy === 'bypass') {

        return next();
    }

    const auth = request.connection.auth;
    const strategy = auth._strategies[request.auth.strategy];

    if (!strategy.methods.payload) {
        return next();
    }

    const config = auth.lookup(request.route);
    const setting = config.payload || (strategy.methods.options.payload ? 'required' : false);
    if (!setting) {
        return next();
    }

    const finalize = (response) => {

        if (response &&
            response.isBoom &&
            response.isMissing) {

            return next(setting === 'optional' ? null : Boom.unauthorized('Missing payload authentication'));
        }

        return next(response);
    };

    request._protect.run(finalize, (exit) => {

        const reply = request.server._replier.interface(request, strategy.realm, {}, exit);
        strategy.methods.payload(request, reply);
    });
}

example usage

...

    return next(response);
};

request._protect.run(finalize, (exit) => {

    const reply = request.server._replier.interface(request, strategy.realm, {}, exit);
    strategy.methods.payload(request, reply);
});
};


internals.Auth.response = function (request, next) {

const auth = request.connection.auth;
...

function hapi.auth.response (request, next)

description and source-code

response = function (request, next) {

    const auth = request.connection.auth;
    const config = auth.lookup(request.route);
    if (!config ||
        !request.auth.isAuthenticated ||
        request.auth.strategy === 'bypass') {

        return next();
    }

    const strategy = auth._strategies[request.auth.strategy];
    if (!strategy.methods.response) {
        return next();
    }

    request._protect.run(next, (exit) => {

        const reply = request.server._replier.interface(request, strategy.realm, {}, exit);
        strategy.methods.response(request, reply);
    });
}

example usage

...
if (!strategy.methods.response) {
    return next();
}

request._protect.run(next, (exit) => {

    const reply = request.server._replier.interface(request, strategy.realm, {}, exit);
    strategy.methods.response(request, reply);
});
};


internals.Authenticator = class {
constructor(config, request, manager) {
...

module hapi.auth.prototype

function hapi.auth.prototype._authenticate (request, next)

description and source-code

_authenticate = function (request, next) {

    const config = this.lookup(request.route);
    if (!config) {
        return next();
    }

    const authenticator = new internals.Authenticator(config, request, this);
    authenticator.authenticate(next);
}

example usage

...
return route.settings.auth || this.settings.default;
};


internals.Auth.authenticate = function (request, next) {

const auth = request.connection.auth;
return auth._authenticate(request, next);
};


internals.Auth.access = function (request, route) {

const auth = request.connection.auth;
const config = auth.lookup(route);
...

function hapi.auth.prototype._setupRoute (options, path)

description and source-code

_setupRoute = function (options, path) {

    if (!options) {
        return options;         // Preserve the difference between undefined and false
    }

    if (typeof options === 'string') {
        options = { strategies: [options] };
    }
    else if (options.strategy) {
        options.strategies = [options.strategy];
        delete options.strategy;
    }

    if (path &&
        !options.strategies) {

        Hoek.assert(this.settings.default, 'Route missing authentication strategy and no default defined:', path);
        options = Hoek.applyToDefaults(this.settings.default, options);
    }

    path = path || 'default strategy';
    Hoek.assert(options.strategies && options.strategies.length, 'Missing authentication strategy:', path);

    options.mode = options.mode || 'required';

    if (options.entity !== undefined ||                                             // Backwards compatibility with <= 11.x.x
        options.scope !== undefined) {

        options.access = [{ entity: options.entity, scope: options.scope }];
        delete options.entity;
        delete options.scope;
    }

    if (options.access) {
        for (let i = 0; i < options.access.length; ++i) {
            const access = options.access[i];
            access.scope = internals.setupScope(access);
        }
    }

    if (options.payload === true) {
        options.payload = 'required';
    }

    let hasAuthenticatePayload = false;
    for (let i = 0; i < options.strategies.length; ++i) {
        const name = options.strategies[i];
        const strategy = this._strategies[name];
        Hoek.assert(strategy, 'Unknown authentication strategy', name, 'in', path);

        Hoek.assert(strategy.methods.payload || options.payload !== 'required', 'Payload validation can only be required when all
 strategies support it in', path);
        hasAuthenticatePayload = hasAuthenticatePayload || strategy.methods.payload;
        Hoek.assert(!strategy.methods.options.payload || options.payload === undefined || options.payload === 'required', 'Cannot
 set authentication payload to', options.payload, 'when a strategy requires payload validation in', path);
    }

    Hoek.assert(!options.payload || hasAuthenticatePayload, 'Payload authentication requires at least one strategy with payload
support in', path);

    return options;
}

example usage

...


internals.Auth.prototype.default = function (options) {

Hoek.assert(!this.settings.default, 'Cannot set default strategy more than once');
options = Schema.apply('auth', options, 'default strategy');

this.settings.default = this._setupRoute(Hoek.clone(options));      // Can change options
};


internals.Auth.prototype.test = function (name, request, next) {

Hoek.assert(name, 'Missing authentication strategy name');
const strategy = this._strategies[name];
...

function hapi.auth.prototype.default (options)

description and source-code

default = function (options) {

    Hoek.assert(!this.settings.default, 'Cannot set default strategy more than once');
    options = Schema.apply('auth', options, 'default strategy');

    this.settings.default = this._setupRoute(Hoek.clone(options));      // Can change options
}

example usage

...
};

if (strategy.api) {
    this.api[name] = strategy.api;
}

if (mode) {
    this.default({ strategies: [name], mode: mode === true ? 'required' : mode
 });
}
};


internals.Auth.prototype.default = function (options) {

Hoek.assert(!this.settings.default, 'Cannot set default strategy more than once');
...

function hapi.auth.prototype.lookup (route)

description and source-code

lookup = function (route) {

    if (route.settings.auth === false) {
        return false;
    }

    return route.settings.auth || this.settings.default;
}

example usage

...
return auth._authenticate(request, next);
};


internals.Auth.access = function (request, route) {

const auth = request.connection.auth;
const config = auth.lookup(route);
if (!config) {
    return true;
}

const credentials = request.auth.credentials;
if (!credentials) {
    return false;
...

function hapi.auth.prototype.scheme (name, scheme)

description and source-code

scheme = function (name, scheme) {

    Hoek.assert(name, 'Authentication scheme must have a name');
    Hoek.assert(!this._schemes[name], 'Authentication scheme name already exists:', name);
    Hoek.assert(typeof scheme === 'function', 'scheme must be a function:', name);

    this._schemes[name] = scheme;
}

example usage
```
n/a
```

function hapi.auth.prototype.strategy (name, scheme)

description and source-code

strategy = function (name, scheme) {

    const hasMode = (typeof arguments[2] === 'string' || typeof arguments[2] === 'boolean');
    const mode = (hasMode ? arguments[2] : false);
    const options = (hasMode ? arguments[3] : arguments[2]) || null;

    Hoek.assert(name, 'Authentication strategy must have a name');
    Hoek.assert(name !== 'bypass', 'Cannot use reserved strategy name: bypass');
    Hoek.assert(!this._strategies[name], 'Authentication strategy name already exists');
    Hoek.assert(scheme, 'Authentication strategy', name, 'missing scheme');
    Hoek.assert(this._schemes[scheme], 'Authentication strategy', name, 'uses unknown scheme:', scheme);

    const server = this.connection.server._clone([this.connection], '');
    const strategy = this._schemes[scheme](server, options);

    Hoek.assert(strategy.authenticate, 'Invalid scheme:', name, 'missing authenticate() method');
    Hoek.assert(typeof strategy.authenticate === 'function', 'Invalid scheme:', name, 'invalid authenticate() method');
    Hoek.assert(!strategy.payload || typeof strategy.payload === 'function', 'Invalid scheme:', name, 'invalid payload() method');
    Hoek.assert(!strategy.response || typeof strategy.response === 'function', 'Invalid scheme:', name, 'invalid response() method
');
    strategy.options = strategy.options || {};
    Hoek.assert(strategy.payload || !strategy.options.payload, 'Cannot require payload validation without a payload method');

    this._strategies[name] = {
        methods: strategy,
        realm: server.realm
    };

    if (strategy.api) {
        this.api[name] = strategy.api;
    }

    if (mode) {
        this.default({ strategies: [name], mode: mode === true ? 'required' : mode });
    }
}

example usage
```
n/a
```

function hapi.auth.prototype.test (name, request, next)

description and source-code

test = function (name, request, next) {

    Hoek.assert(name, 'Missing authentication strategy name');
    const strategy = this._strategies[name];
    Hoek.assert(strategy, 'Unknown authentication strategy:', name);

    const reply = request.server._replier.interface(request, strategy.realm, { data: true }, (response) => next(response, reply.
_data && reply._data.credentials));
    strategy.methods.authenticate(request, reply);
}

example usage

...
    const prefix = value[0];
    const type = (prefix === '+' ? 'required' : (prefix === '!' ? 'forbidden' : 'selection
'));
    const clean = (type === 'selection' ? value : value.slice(1));
    scope[type] = scope[type] || [];
    scope[type].push(clean);

    if ((!scope._parameters || !scope._parameters[type]) &&
        /{([^}]+)}/.test(clean)) {

        scope._parameters = scope._parameters || {};
        scope._parameters[type] = true;
    }
}

return scope;
...

module hapi.compression

function hapi.compression ()

description and source-code

compression = function () {

    this.encodings = ['identity', 'gzip', 'deflate'];
    this._encoders = {
        identity: null,
        gzip: (options) => Zlib.createGzip(options),
        deflate: (options) => Zlib.createDeflate(options)
    };

    this._decoders = {
        gzip: (options) => Zlib.createGunzip(options),
        deflate: (options) => Zlib.createInflate(options)
    };
}

example usage
```
n/a
```

module hapi.compression.prototype

function hapi.compression.prototype.accept (request)

description and source-code

accept = function (request) {

    return Accept.encoding(request.headers['accept-encoding'], this.encodings);
}

example usage

...
this.info = {
    received: now,
    responded: 0,
    remoteAddress: req.connection.remoteAddress,
    remotePort: req.connection.remotePort || '',
    referrer: req.headers.referrer || req.headers.referer || '',
    host: req.headers.host ? req.headers.host.replace(/\s/g, '') : '',
    acceptEncoding: this.connection._compression.accept(this)
};

this.info.hostname = this.info.host.split(':')[0];

// Assigned elsewhere:

this.orig = {};
...

function hapi.compression.prototype.addDecoder (encoding, decoder)

description and source-code

addDecoder = function (encoding, decoder) {

    Hoek.assert(this._decoders[encoding] === undefined, `Cannot override existing decoder for ${encoding}`);
    Hoek.assert(typeof decoder === 'function', `Invalid decoder function for ${encoding}`);
    this._decoders[encoding] = decoder;
}

example usage

...

    return match.route.public;
};


internals.Connection.prototype.decoder = function (encoding, decoder) {

    return this._compression.addDecoder(encoding, decoder);
};


internals.Connection.prototype.encoder = function (encoding, encoder) {

    return this._compression.addEncoder(encoding, encoder);
};
...

function hapi.compression.prototype.addEncoder (encoding, encoder)

description and source-code

addEncoder = function (encoding, encoder) {

    Hoek.assert(this._encoders[encoding] === undefined, `Cannot override existing encoder for ${encoding}`);
    Hoek.assert(typeof encoder === 'function', `Invalid encoder function for ${encoding}`);
    this._encoders[encoding] = encoder;
    this.encodings.push(encoding);
}

example usage

...

return this._compression.addDecoder(encoding, decoder);
};


internals.Connection.prototype.encoder = function (encoding, encoder) {

return this._compression.addEncoder(encoding, encoder);
};


internals.Connection.prototype._ext = function (event) {

const type = event.type;
Hoek.assert(this._extensions[type], 'Unknown event type', type);
...

function hapi.compression.prototype.encoder (request, encoding)

description and source-code

encoder = function (request, encoding) {

    const encoder = this._encoders[encoding];
    Hoek.assert(encoder !== undefined, `Unknown encoding ${encoding}`);
    return encoder(request.route.settings.compression[encoding]);
}

example usage

...
length !== 0 &&
response.statusCode !== 206 &&
response._isPayloadSupported()) {

delete response.headers['content-length'];
response._header('content-encoding', encoding);

compressor = request.connection._compression.encoder(request, encoding);
    }

    if ((response.headers['content-encoding'] || encoding) &&
response.headers.etag &&
response.settings.varyEtag) {

response.headers.etag = response.headers.etag.slice(0, -1) + '-' + (response.headers['content-encoding'] ||
encoding) + '"';
...

function hapi.compression.prototype.encoding (response)

description and source-code

encoding = function (response) {

    const request = response.request;
    if (!request.connection.settings.compression) {
        return null;
    }

    const mime = request.server.mime.type(response.headers['content-type'] || 'application/octet-stream');
    if (!mime.compressible) {
        return null;
    }

    response.vary('accept-encoding');

    if (response.headers['content-encoding']) {
        return null;
    }

    return (request.info.acceptEncoding === 'identity' ? null : request.info.acceptEncoding);
}

example usage

...
Hoek.assert(typeof decoder === 'function', `Invalid decoder function for ${encoding}`);
this._decoders[encoding] = decoder;
};


internals.Compression.prototype.accept = function (request) {

return Accept.encoding(request.headers['accept-encoding'], this.encodings);
};


internals.Compression.prototype.encoding = function (response) {

const request = response.request;
if (!request.connection.settings.compression) {
...

module hapi.connection

function hapi.connection (server, options)

description and source-code

connection = function (server, options) {

    const now = Date.now();

    Podium.call(this, internals.Connection._events);

    this.settings = options;                                                        // options cloned in server.connection()
    this.server = server;

    // Normalize settings

    this.settings.labels = Hoek.unique(this.settings.labels || []);                 // Remove duplicates
    if (this.settings.port === undefined) {
        this.settings.port = 0;
    }

    this.type = (typeof this.settings.port === 'string' ? 'socket' : 'tcp');
    if (this.type === 'socket') {
        this.settings.port = (this.settings.port.indexOf('/') !== -1 ? Path.resolve(this.settings.port) : this.settings.port.toLowerCase
());
    }

    if (this.settings.autoListen === undefined) {
        this.settings.autoListen = true;
    }

    Hoek.assert(this.settings.autoListen || !this.settings.port, 'Cannot specify port when autoListen is false');
    Hoek.assert(this.settings.autoListen || !this.settings.address, 'Cannot specify address when autoListen is false');

    // Connection facilities

    this._started = false;
    this._connections = {};
    this._onConnection = null;          // Used to remove event listener on stop
    this.registrations = {};            // Tracks plugin for dependency validation { name -> { version } }

    this._extensions = {
        onRequest: new Ext('onRequest', this.server),
        onPreAuth: new Ext('onPreAuth', this.server),
        onPostAuth: new Ext('onPostAuth', this.server),
        onPreHandler: new Ext('onPreHandler', this.server),
        onPostHandler: new Ext('onPostHandler', this.server),
        onPreResponse: new Ext('onPreResponse', this.server)
    };

    this._requestCounter = { value: internals.counter.min, min: internals.counter.min, max: internals.counter.max };
    this._load = server._heavy.policy(this.settings.load);
    this._compression = new Compression();
    this.states = new Statehood.Definitions(this.settings.state);
    this.auth = new Auth(this);
    this._router = new Call.Router(this.settings.router);
    this._defaultRoutes();

    this.plugins = {};                  // Registered plugin APIs by plugin name
    this.app = {};                      // Place for application-specific state without conflicts with hapi, should not be used
by plugins

    // Create listener

    this.listener = this.settings.listener || (this.settings.tls ? Https.createServer(this.settings.tls) : Http.createServer());
    this.listener.on('request', this._dispatch());
    this._init();

    this.listener.on('clientError', (err, socket) => {

        this.server._log(['connection', 'client', 'error'], err);
    });

    // Connection information

    this.info = {
        created: now,
        started: 0,
        host: this.settings.host || Os.hostname() || 'localhost',
        port: this.settings.port,
        protocol: this.type === 'tcp' ? (this.settings.tls ? 'https' : 'http') : this.type,
        id: Os.hostname() + ':' + process.pid + ':' + now.toString(36)
    };

    this.info.uri = (this.settings.uri || (this.info.protocol + ':' + (this.type === 'tcp' ? '//' + this.info.host + (this.info.
port ? ':' + this.info.port : '') : this.info.port)));

    this.on('route', Cors.options);
}

example usage

...

exports = module.exports = internals.Connection = function (server, options) {

const now = Date.now();

Podium.call(this, internals.Connection._events);

this.settings = options;                                                        // options cloned in server.connection()
this.server = server;

// Normalize settings

this.settings.labels = Hoek.unique(this.settings.labels || []);                 // Remove duplicates
if (this.settings.port === undefined) {
    this.settings.port = 0;
...

function hapi.connection.super_ (events)

description and source-code

super_ = function (events) {

    // Use descriptive names to avoid conflict when inherited

    this._eventListeners = Object.create(null);
    this._notificationsQueue = [];
    this._eventsProcessing = false;
    this._sourcePodiums = [];

    if (events) {
        this.registerEvent(events);
    }
}

example usage
```
n/a
```

module hapi.connection.prototype

function hapi.connection.prototype._addRoute (config, plugin)

description and source-code

_addRoute = function (config, plugin) {

    const route = new Route(config, this, plugin);                // Do no use config beyond this point, use route members
    const vhosts = [].concat(route.settings.vhost || '*');

    for (let i = 0; i < vhosts.length; ++i) {
        const vhost = vhosts[i];
        const record = this._router.add({ method: route.method, path: route.path, vhost, analysis: route._analysis, id: route.settings
.id }, route);
        route.fingerprint = record.fingerprint;
        route.params = record.params;
    }

    this.emit('route', [route.public, this, plugin]);
}

example usage

...

        if (Array.isArray(config.method)) {
            for (let j = 0; j < config.method.length; ++j) {
                const method = config.method[j];

                const settings = Hoek.shallow(config);
                settings.method = method;
                this._addRoute(settings, plugin);
            }
        }
        else {
            this._addRoute(config, plugin);
        }
    }
};
...

function hapi.connection.prototype._defaultRoutes ()

description and source-code

_defaultRoutes = function () {

    this._router.special('notFound', new Route({ method: '_special', path: '/{p*}', handler: internals.notFound }, this, this.server
, { special: true }));
    this._router.special('badRequest', new Route({ method: '_special', path: '/{p*}', handler: internals.badRequest }, this, this
.server, { special: true }));

    if (this.settings.routes.cors) {
        Cors.handler(this);
    }
}

example usage

...

this._requestCounter = { value: internals.counter.min, min: internals.counter.min, max: internals.counter.max };
this._load = server._heavy.policy(this.settings.load);
this._compression = new Compression();
this.states = new Statehood.Definitions(this.settings.state);
this.auth = new Auth(this);
this._router = new Call.Router(this.settings.router);
this._defaultRoutes();

this.plugins = {};                  // Registered plugin APIs by plugin name
this.app = {};                      // Place for application-specific state without conflicts with hapi, should not be used by plugins

// Create listener

this.listener = this.settings.listener || (this.settings.tls ? Https.createServer(this.settings.tls) : Http.createServer());
...

function hapi.connection.prototype._dispatch (options)

description and source-code

_dispatch = function (options) {

    options = options || {};

    return (req, res) => {

        // Track socket request processing state

        if (req.socket) {
            req.socket._isHapiProcessing = true;
            res.on('finish', () => {

                req.socket._isHapiProcessing = false;
                if (!this._started) {
                    req.socket.end();
                }
            });
        }

        // Create request

        const request = this.server._requestor.request(this, req, res, options);

        // Check load

        const overload = this._load.check();
        if (overload) {
            this.server._log(['load'], this.server.load);
            request._reply(overload);
        }
        else {

            // Execute request lifecycle

            request._protect.enter(() => {

                request._execute();
            });
        }
    };
}

example usage

...

this.plugins = {};                  // Registered plugin APIs by plugin name
this.app = {};                      // Place for application-specific state without conflicts with hapi, should not be used by plugins

// Create listener

this.listener = this.settings.listener || (this.settings.tls ? Https.createServer(this.settings.tls) : Http.createServer());
this.listener.on('request', this._dispatch());
this._init();

this.listener.on('clientError', (err, socket) => {

    this.server._log(['connection', 'client', 'error'], err);
});
...

function hapi.connection.prototype._ext (event)

description and source-code

_ext = function (event) {

    const type = event.type;
    Hoek.assert(this._extensions[type], 'Unknown event type', type);
    this._extensions[type].add(event);
}

example usage
```
n/a
```

function hapi.connection.prototype._init ()

description and source-code

_init = function () {

    // Setup listener

    this.listener.once('listening', () => {

        // Update the address, port, and uri with active values

        if (this.type === 'tcp') {
            const address = this.listener.address();
            this.info.address = address.address;
            this.info.port = address.port;
            this.info.uri = (this.settings.uri || (this.info.protocol + '://' + this.info.host + ':' + this.info.port));
        }

        this._onConnection = (connection) => {

            const key = connection.remoteAddress + ':' + connection.remotePort;
            this._connections[key] = connection;

            connection.once('close', () => {

                delete this._connections[key];
            });
        };

        this.listener.on(this.settings.tls ? 'secureConnection' : 'connection', this._onConnection);
    });
}

example usage

...
this.plugins = {};                  // Registered plugin APIs by plugin name
this.app = {};                      // Place for application-specific state without conflicts with hapi, should not be used by plugins

// Create listener

this.listener = this.settings.listener || (this.settings.tls ? Https.createServer(this.settings.tls) : Http.createServer());
this.listener.on('request', this._dispatch());
this._init();

this.listener.on('clientError', (err, socket) => {

    this.server._log(['connection', 'client', 'error'], err);
});

// Connection information
...

function hapi.connection.prototype._route (configs, plugin)

description and source-code

_route = function (configs, plugin) {

    configs = [].concat(configs);
    for (let i = 0; i < configs.length; ++i) {
        const config = configs[i];

        if (Array.isArray(config.method)) {
            for (let j = 0; j < config.method.length; ++j) {
                const method = config.method[j];

                const settings = Hoek.shallow(config);
                settings.method = method;
                this._addRoute(settings, plugin);
            }
        }
        else {
            this._addRoute(config, plugin);
        }
    }
}

example usage
```
n/a
```

function hapi.connection.prototype._start (callback)

description and source-code

_start = function (callback) {

    if (this._started) {
        return process.nextTick(callback);
    }

    this._started = true;
    this.info.started = Date.now();

    if (!this.settings.autoListen) {
        return process.nextTick(callback);
    }

    const onError = (err) => {

        this._started = false;
        return callback(err);
    };

    this.listener.once('error', onError);

    const finalize = () => {

        this.listener.removeListener('error', onError);
        callback();
    };

    if (this.type !== 'tcp') {
        this.listener.listen(this.settings.port, finalize);
    }
    else {
        const address = this.settings.address || this.settings.host || '0.0.0.0';
        this.listener.listen(this.settings.port, address, finalize);
    }
}

example usage
```
n/a
```

function hapi.connection.prototype._stop (options, callback)

description and source-code

_stop = function (options, callback) {

    if (!this._started) {
        return process.nextTick(callback);
    }

    this._started = false;
    this.info.started = 0;

    const timeoutId = setTimeout(() => {

        Object.keys(this._connections).forEach((key) => {

            this._connections[key].destroy();
        });


        this._connections = {};
    }, options.timeout);

    this.listener.close(() => {

        this.listener.removeListener(this.settings.tls ? 'secureConnection' : 'connection', this._onConnection);
        clearTimeout(timeoutId);

        this._init();
        return callback();
    });

    // Tell idle keep-alive connections to close

    Object.keys(this._connections).forEach((key) => {

        const connection = this._connections[key];
        if (!connection._isHapiProcessing) {
            connection.end();
        }
    });
}

example usage
```
n/a
```

function hapi.connection.prototype.decoder (encoding, decoder)

description and source-code

decoder = function (encoding, decoder) {

    return this._compression.addDecoder(encoding, decoder);
}

example usage
```
n/a
```

function hapi.connection.prototype.encoder (encoding, encoder)

description and source-code

encoder = function (encoding, encoder) {

    return this._compression.addEncoder(encoding, encoder);
}

example usage

...
length !== 0 &&
response.statusCode !== 206 &&
response._isPayloadSupported()) {

delete response.headers['content-length'];
response._header('content-encoding', encoding);

compressor = request.connection._compression.encoder(request, encoding);
    }

    if ((response.headers['content-encoding'] || encoding) &&
response.headers.etag &&
response.settings.varyEtag) {

response.headers.etag = response.headers.etag.slice(0, -1) + '-' + (response.headers['content-encoding'] ||
encoding) + '"';
...

function hapi.connection.prototype.inject (options, callback)

description and source-code

inject = function (options, callback) {

    if (!callback) {
        return new Promise((resolve, reject) => this.inject(options, (res) => resolve(res)));
    }

    let settings = options;
    if (typeof settings === 'string') {
        settings = { url: settings };
    }

    if (!settings.authority ||
        settings.credentials ||
        settings.app ||
        settings.plugins ||
        settings.allowInternals !== undefined) {        // Can be false

        settings = Hoek.shallow(settings);              // options can be reused
        delete settings.credentials;
        delete settings.artifacts;                      // Cannot appear without credentials
        delete settings.app;
        delete settings.plugins;
        delete settings.allowInternals;

        settings.authority = settings.authority || (this.info.host + ':' + this.info.port);
    }

    const needle = this._dispatch({
        credentials: options.credentials,
        artifacts: options.artifacts,
        allowInternals: options.allowInternals,
        app: options.app,
        plugins: options.plugins
    });

    Shot.inject(needle, settings, (res) => {

        if (res.raw.res._hapi) {
            res.result = res.raw.res._hapi.result;
            res.request = res.raw.res._hapi.request;
            delete res.raw.res._hapi;
        }

        if (res.result === undefined) {
            res.result = res.payload;
        }

        return callback(res);
    });
}

example usage

...
};
};


internals.Connection.prototype.inject = function (options, callback) {

if (!callback) {
    return new Promise((resolve, reject) => this.inject(options, (res) => resolve
(res)));
}

let settings = options;
if (typeof settings === 'string') {
    settings = { url: settings };
}
...

function hapi.connection.prototype.lookup (id)

description and source-code

lookup = function (id) {

    Hoek.assert(id && typeof id === 'string', 'Invalid route id:', id);

    const record = this._router.ids[id];
    if (!record) {
        return null;
    }

    return record.route.public;
}

example usage

...
return auth._authenticate(request, next);
};


internals.Auth.access = function (request, route) {

const auth = request.connection.auth;
const config = auth.lookup(route);
if (!config) {
    return true;
}

const credentials = request.auth.credentials;
if (!credentials) {
    return false;
...

function hapi.connection.prototype.match (method, path, host)

description and source-code

match = function (method, path, host) {

    Hoek.assert(method && typeof method === 'string', 'Invalid method:', method);
    Hoek.assert(path && typeof path === 'string' && path[0] === '/', 'Invalid path:', path);
    Hoek.assert(!host || typeof host === 'string', 'Invalid host:', host);

    const match = this._router.route(method.toLowerCase(), path, host);
    Hoek.assert(match !== this._router.specials.badRequest, 'Invalid path:', path);
    if (match === this._router.specials.notFound) {
        return null;
    }

    return match.route.public;
}

example usage

...
const method = request.headers['access-control-request-method'];
if (!method) {
    return reply(Boom.notFound('CORS error: Missing Access-Control-Request-Method header'));
}

// Lookup route

const route = request.connection.match(method, request.path, request.info.hostname);
if (!route) {
    return reply(Boom.notFound());
}

const settings = route.settings.cors;
if (!settings) {
    return reply({ message: 'CORS is disabled for this route' });
...

function hapi.connection.prototype.table (host)

description and source-code

table = function (host) {

    return this._router.table(host);
}

example usage

...
    return callback(res);
});
};


internals.Connection.prototype.table = function (host) {

return this._router.table(host);
};


internals.Connection.prototype.lookup = function (id) {

Hoek.assert(id && typeof id === 'string', 'Invalid route id:', id);
...

module hapi.cors

function hapi.cors.handler (connection)

description and source-code

handler = function (connection) {

    Route = Route || require('./route');

    if (connection._router.specials.options) {
        return;
    }

    const route = new Route({ method: '_special', path: '/{p*}', handler: internals.handler }, connection, connection.server, {
special: true });
    connection._router.special('options', route);
}

example usage

...

internals.Connection.prototype._defaultRoutes = function () {

this._router.special('notFound', new Route({ method: '_special', path: '/{p*}', handler: internals
.notFound }, this, this.server, { special: true }));
this._router.special('badRequest', new Route({ method: '_special', path: '/{p*}', handler: internals
.badRequest }, this, this.server, { special: true }));

if (this.settings.routes.cors) {
    Cors.handler(this);
}
};


internals.notFound = function (request, reply) {

return reply(Boom.notFound());
...

function hapi.cors.headers (response)

description and source-code

headers = function (response) {

    const request = response.request;
    if (request._route._special) {
        return;
    }

    const settings = request.route.settings.cors;
    if (!settings) {
        return;
    }

    response.vary('origin');

    if (!request.info.cors.isOriginMatch) {
        return;
    }

    response._header('access-control-allow-origin', request.headers.origin);

    if (settings.credentials) {
        response._header('access-control-allow-credentials', 'true');
    }

    if (settings._exposedHeaders) {
        response._header('access-control-expose-headers', settings._exposedHeaders, { append: true });
    }
}

example usage

...
};


internals.marshal = function (request, next) {

    const response = request.response;

    Cors.headers(response);
    internals.content(response, false);
    internals.security(response);
    internals.unmodified(response);

    internals.state(response, (err) => {

if (err) {
...

function hapi.cors.matchOrigin (origin, settings)

description and source-code

matchOrigin = function (origin, settings) {

    if (!origin) {
        return false;
    }

    if (settings._origin === true) {
        return true;
    }

    if (settings._origin.qualified.indexOf(origin) !== -1) {
        return true;
    }

    for (let i = 0; i < settings._origin.wildcards.length; ++i) {
        if (origin.match(settings._origin.wildcards[i])) {
            return true;
        }
    }

    return false;
}

example usage

...
const settings = route.settings.cors;
if (!settings) {
    return reply({ message: 'CORS is disabled for this route' });
}

// Validate Origin header

if (!exports.matchOrigin(origin, settings)) {
    return reply({ message: 'CORS error: Origin not allowed' });
}

// Validate allowed headers

let headers = request.headers['access-control-request-headers'];
if (headers) {
...

function hapi.cors.options (route, connection, server)

description and source-code

options = function (route, connection, server) {

    if (route.method === 'options' ||
        !route.settings.cors) {

        return;
    }

    exports.handler(connection);
}

example usage

...


internals.cachePolicy = Joi.object({
cache: Joi.string().allow(null).allow(''),
segment: Joi.string(),
shared: Joi.boolean()
})
.options({ allowUnknown: true });               // Catbox validates other keys


internals.method = Joi.object({
bind: Joi.object().allow(null),
generateKey: Joi.func(),
cache: internals.cachePolicy,
callback: Joi.boolean()
...

function hapi.cors.route (options)

description and source-code

route = function (options) {

    const settings = Hoek.applyToDefaults(Defaults.cors, options);
    if (!settings) {
        return false;
    }

    settings._headers = settings.headers.concat(settings.additionalHeaders);
    settings._headersString = settings._headers.join(',');
    for (let i = 0; i < settings._headers.length; ++i) {
        settings._headers[i] = settings._headers[i].toLowerCase();
    }

    if (settings._headers.indexOf('origin') === -1) {
        settings._headers.push('origin');
    }

    settings._exposedHeaders = settings.exposedHeaders.concat(settings.additionalExposedHeaders).join(',');

    if (settings.origin.indexOf('*') !== -1) {
        Hoek.assert(settings.origin.length === 1, 'Cannot specify cors.origin * together with other values');
        settings._origin = true;
    }
    else {
        settings._origin = {
            qualified: [],
            wildcards: []
        };

        for (let i = 0; i < settings.origin.length; ++i) {
            const origin = settings.origin[i];
            if (origin.indexOf('*') !== -1) {
                settings._origin.wildcards.push(new RegExp('^' + Hoek.escapeRegex(origin).replace(/\\\*/g, '.*').replace(/\\\?/g
, '.') + '$'));
            }
            else {
                settings._origin.qualified.push(origin);
            }
        }
    }

    return settings;
}

example usage

...

internals.Connection.prototype.match = function (method, path, host) {

    Hoek.assert(method && typeof method === 'string', 'Invalid method:', method);
    Hoek.assert(path && typeof path === 'string' && path[0] === '/', 'Invalid path:&#
x27;, path);
    Hoek.assert(!host || typeof host === 'string', 'Invalid host:', host);

    const match = this._router.route(method.toLowerCase(), path, host);
    Hoek.assert(match !== this._router.specials.badRequest, 'Invalid path:', path);
    if (match === this._router.specials.notFound) {
        return null;
    }

    return match.route.public;
};
...

module hapi.ext

function hapi.ext (type, server)

description and source-code

ext = function (type, server) {

    this._topo = new Topo();
    this._server = server;
    this._routes = [];

    this.type = type;
    this.nodes = null;
}

example usage
```
n/a
```

module hapi.ext.prototype

function hapi.ext.prototype.add (event)

description and source-code

add = function (event) {

    const methods = [].concat(event.method);
    const options = event.options;

    for (let i = 0; i < methods.length; ++i) {
        const settings = {
            before: options.before,
            after: options.after,
            group: event.plugin.realm.plugin,
            sort: this._server._extensionsSeq++
        };

        const node = {
            func: methods[i],                 // Connection: function (request, next), Server: function (server, next)
            bind: options.bind,
            plugin: event.plugin
        };

        this._topo.add(node, settings);
    }

    this.nodes = this._topo.nodes;

    // Notify routes

    for (let i = 0; i < this._routes.length; ++i) {
        this._routes[i].rebuild(event);
    }
}

example usage

...
};


internals.Connection.prototype._ext = function (event) {

const type = event.type;
Hoek.assert(this._extensions[type], 'Unknown event type', type);
this._extensions[type].add(event);
};


internals.Connection.prototype._route = function (configs, plugin) {

configs = [].concat(configs);
for (let i = 0; i < configs.length; ++i) {
...

function hapi.ext.prototype.merge (others)

description and source-code

merge = function (others) {

    const merge = [];
    for (let i = 0; i < others.length; ++i) {
        merge.push(others[i]._topo);
    }

    this._topo.merge(merge);
    this.nodes = (this._topo.nodes.length ? this._topo.nodes : null);
}

example usage

...
internals.Ext.prototype.merge = function (others) {

const merge = [];
for (let i = 0; i < others.length; ++i) {
    merge.push(others[i]._topo);
}

this._topo.merge(merge);
this.nodes = (this._topo.nodes.length ? this._topo.nodes : null);
};


internals.Ext.prototype.subscribe = function (route) {

this._routes.push(route);
...

function hapi.ext.prototype.subscribe (route)

description and source-code

subscribe = function (route) {

    this._routes.push(route);
}

example usage

...
    }

    const connection = this.connection._extensions[type];
    const realm = this.plugin.realm._extensions[type];

    ext.merge([connection, realm]);

    connection.subscribe(this);
    realm.subscribe(this);

    return ext;
};


internals.Route.prototype.rebuild = function (event) {
...

module hapi.handler

function hapi.handler.configure (handler, route)

description and source-code

configure = function (handler, route) {

    if (typeof handler === 'object') {
        const type = Object.keys(handler)[0];
        const serverHandler = route.server._handlers[type];

        Hoek.assert(serverHandler, 'Unknown handler:', type);

        return serverHandler(route.public, handler[type]);
    }

    if (typeof handler === 'string') {
        const parsed = internals.fromString('handler', handler, route.server);
        return parsed.method;
    }

    return handler;
}

example usage

...
            security._xframe = security.xframe.rule.toUpperCase();
        }
    }
}

// Handler

this.settings.handler = Handler.configure(this.settings.handler, this);
this._prerequisites = Handler.prerequisitesConfig(this.settings.pre, this.server);

// Route lifecycle

this._extensions = {
    onPreResponse: this._combineExtensions('onPreResponse')
};
...

function hapi.handler.defaults (method, handler, server)

description and source-code

defaults = function (method, handler, server) {

    let defaults = null;

    if (typeof handler === 'object') {
        const type = Object.keys(handler)[0];
        const serverHandler = server._handlers[type];

        Hoek.assert(serverHandler, 'Unknown handler:', type);

        if (serverHandler.defaults) {
            defaults = (typeof serverHandler.defaults === 'function' ? serverHandler.defaults(method) : serverHandler.defaults);
        }
    }

    return defaults || {};
}

example usage

...
    if (typeof handler === 'object') {
        const type = Object.keys(handler)[0];
        const serverHandler = server._handlers[type];

        Hoek.assert(serverHandler, 'Unknown handler:', type);

        if (serverHandler.defaults) {
            defaults = (typeof serverHandler.defaults === 'function' ? serverHandler.defaults(method) : serverHandler.defaults);
        }
    }

    return defaults || {};
};
...

function hapi.handler.execute (request, next)

description and source-code

execute = function (request, next) {

    const finalize = (err, result) => {

        request._setResponse(err || result);
        return next();                              // Must not include an argument
    };

    request._protect.run(finalize, (exit) => {

        if (request._route._prerequisites) {
            internals.prerequisites(request, Hoek.once(exit));
        }
        else {
            internals.handler(request, exit);
        }
    });
}

example usage

...

if (this.request.auth.credentials) {
    return this.validate(null, { credentials: this.request.auth.credentials, artifacts: this.request.auth.artifacts }, next);
}

// Authenticate

return this.execute(next);
    }

    execute(next) {

const config = this.config;
const request = this.request;
...

function hapi.handler.prerequisitesConfig (config, server)

description and source-code

prerequisitesConfig = function (config, server) {

    if (!config) {
        return null;
    }

    /*
        [
            [
                function (request, reply) { },
                {
                    method: function (request, reply) { }
                    assign: key1
                },
                {
                    method: function (request, reply) { },
                    assign: key2
                }
            ],
            'user(params.id)'
        ]
    */

    const prerequisites = [];

    for (let i = 0; i < config.length; ++i) {
        const pres = [].concat(config[i]);

        const set = [];
        for (let j = 0; j < pres.length; ++j) {
            let pre = pres[j];
            if (typeof pre !== 'object') {
                pre = { method: pre };
            }

            const item = {
                method: pre.method,
                assign: pre.assign,
                failAction: pre.failAction || 'error'
            };

            if (typeof item.method === 'string') {
                const parsed = internals.fromString('pre', item.method, server);
                item.method = parsed.method;
                item.assign = item.assign || parsed.name;
            }

            set.push(internals.pre(item));
        }

        prerequisites.push(set);
    }

    return prerequisites.length ? prerequisites : null;
}

example usage

...
        }
    }
}

// Handler

this.settings.handler = Handler.configure(this.settings.handler, this);
this._prerequisites = Handler.prerequisitesConfig(this.settings.pre, this.server);

// Route lifecycle

this._extensions = {
    onPreResponse: this._combineExtensions('onPreResponse')
};
...

module hapi.methods

function hapi.methods (server)

description and source-code

methods = function (server) {

    this.server = server;
    this.methods = {};
    this._normalized = {};
}

example usage
```
n/a
```

module hapi.methods.prototype

function hapi.methods.prototype._add (name, method, options, realm)

description and source-code

_add = function (name, method, options, realm) {

    Hoek.assert(typeof method === 'function', 'method must be a function');
    Hoek.assert(typeof name === 'string', 'name must be a string');
    Hoek.assert(name.match(exports.methodNameRx), 'Invalid name:', name);
    Hoek.assert(!Hoek.reach(this.methods, name, { functions: false }), 'Server method function name already exists:', name);

    options = Schema.apply('method', options || {}, name);

    const settings = Hoek.cloneWithShallow(options, ['bind']);
    settings.generateKey = settings.generateKey || internals.generateKey;
    const bind = settings.bind || realm.settings.bind || null;

    const apply = function () {

        return method.apply(bind, arguments);
    };

    const bound = bind ? apply : method;

    // Normalize methods

    let normalized = bound;
    if (settings.callback === false) {                                          // Defaults to true
        normalized = function (/* arg1, arg2, ..., argn, methodNext */) {

            const args = [];
            for (let i = 0; i < arguments.length - 1; ++i) {
                args.push(arguments[i]);
            }

            const methodNext = arguments[arguments.length - 1];

            let result = null;
            let error = null;

            try {
                result = method.apply(bind, args);
            }
            catch (err) {
                error = err;
            }

            if (result instanceof Error) {
                error = result;
                result = null;
            }

            if (error ||
                typeof result !== 'object' ||
                typeof result.then !== 'function') {

                return methodNext(error, result);
            }

            // Promise object

            const onFulfilled = (outcome) => methodNext(null, outcome);
            const onRejected = (err) => methodNext(err);
            result.then(onFulfilled, onRejected);
        };
    }

    // Not cached

    if (!settings.cache) {
        return this._assign(name, bound, normalized);
    }

    // Cached

    Hoek.assert(!settings.cache.generateFunc, 'Cannot set generateFunc with method caching:', name);
    Hoek.assert(settings.cache.generateTimeout !== undefined, 'Method caching requires a timeout value in generateTimeout:', name
);

    settings.cache.generateFunc = (id, next) => {

        id.args.push(next);                     // function (err, result, ttl)
        normalized.apply(bind, id.args);
    };

    const cache = this.server.cache(settings.cache, '#' + name);

    const func = function (/* arguments, methodNext */) {

        const args = [];
        for (let i = 0; i < arguments.length - 1; ++i) {
            args.push(arguments[i]);
        }

        const methodNext = arguments[arguments.length - 1];

        const key = settings.generateKey.apply(bind, args);
        if (key === null ||                                 // Value can be ''
            typeof key !== 'string') {                      // When using custom generateKey

            return Hoek.nextTick(methodNext)(Boom.badImplementation('Invalid method key when invoking: ' + name, { name, args }));
        }

        cache.get({ id: key, args }, methodNext);
    };

    func.cache = {
        drop: function (/* arguments, callback */) {

            const args = [];
            for (let i = 0; i < arguments.length - 1; ++i) {
                args.push(arguments[i]);
            }

            const methodNext = arguments[arguments.length - 1];

            const key = settings.generateKey.apply(null, args);
            if (key === null) {                             // Value can be ''
                return Hoek.nextTick(methodNext)(Boom.badImplementation('Invalid method key'));
            }

            return cache.drop(key, methodNext);
        },
        stats: cache.stats
    };

    this._assign(name, func, func);
}

example usage

...
this._normalized = {};
};


internals.Methods.prototype.add = function (name, method, options, realm) {

if (typeof name !== 'object') {
    return this._add(name, method, options, realm);
}

// {} or [{}, {}]

const items = [].concat(name);
for (let i = 0; i < items.length; ++i) {
    const item = Schema.apply('methodObject', items[i]);
...

function hapi.methods.prototype._assign (name, method, normalized)

description and source-code

_assign = function (name, method, normalized) {

    const path = name.split('.');
    let ref = this.methods;
    for (let i = 0; i < path.length; ++i) {
        if (!ref[path[i]]) {
            ref[path[i]] = (i + 1 === path.length ? method : {});
        }

        ref = ref[path[i]];
    }

    this._normalized[name] = normalized;
}

example usage

...
        result.then(onFulfilled, onRejected);
    };
}

// Not cached

if (!settings.cache) {
    return this._assign(name, bound, normalized);
}

// Cached

Hoek.assert(!settings.cache.generateFunc, 'Cannot set generateFunc with method caching:', name);
Hoek.assert(settings.cache.generateTimeout !== undefined, 'Method caching requires a timeout value in generateTimeout:'
;, name);
...

function hapi.methods.prototype.add (name, method, options, realm)

description and source-code

add = function (name, method, options, realm) {

    if (typeof name !== 'object') {
        return this._add(name, method, options, realm);
    }

    // {} or [{}, {}]

    const items = [].concat(name);
    for (let i = 0; i < items.length; ++i) {
        const item = Schema.apply('methodObject', items[i]);
        this._add(item.name, item.method, item.options, realm);
    }
}

example usage

...
};


internals.Connection.prototype._ext = function (event) {

const type = event.type;
Hoek.assert(this._extensions[type], 'Unknown event type', type);
this._extensions[type].add(event);
};


internals.Connection.prototype._route = function (configs, plugin) {

configs = [].concat(configs);
for (let i = 0; i < configs.length; ++i) {
...

module hapi.promises

function hapi.promises.wrap (bind, method, args)

description and source-code

wrap = function (bind, method, args) {

    return new Promise((resolve, reject) => {

        const callback = (err, result) => {

            if (err) {
                return reject(err);
            }

            return resolve(result);
        };

        method.apply(bind, args ? args.concat(callback) : [callback]);
    });
}

example usage

...

internals.handler = function (request, callback) {

    const timer = new Hoek.Bench();
    const finalize = (response) => {

if (response === null) {                            // reply.continue()
    response = Response.wrap(null, request);
    return response._prepare(finalize);
}

// Check for Error result

if (response.isBoom) {
    request._log(['handler', 'error'], { msec: timer.elapsed(), error: response.message, data: response });
...

module hapi.protect

function hapi.protect (request)

description and source-code

protect = function (request) {

    this._error = null;
    this.logger = request;                          // Replaced with server when request completes

    if (!request.server.settings.useDomains) {
        this.domain = null;
        return;
    }

    Domain = Domain || require('domain');

    this.domain = Domain.create();
    this.domain.on('error', (err) => {

        return this._onError(err);
    });
}

example usage
```
n/a
```

module hapi.protect.prototype

function hapi.protect.prototype._onError (err)

description and source-code

_onError = function (err) {

    const handler = this._error;
    if (handler) {
        this._error = null;
        return handler(err);
    }

    this.logger._log(['internal', 'implementation', 'error'], err);
}

example usage

...
}

Domain = Domain || require('domain');

this.domain = Domain.create();
this.domain.on('error', (err) => {

    return this._onError(err);
});
};


internals.Protect.prototype._onError = function (err) {

const handler = this._error;
...

function hapi.protect.prototype.enter (func)

description and source-code

enter = function (func) {

    if (!this.domain) {
        return func();
    }

    this.domain.run(func);
}

example usage

...
            this.server._log(['load'], this.server.load);
            request._reply(overload);
        }
        else {

            // Execute request lifecycle

            request._protect.enter(() => {

                request._execute();
            });
        }
    };
};
...

function hapi.protect.prototype.reset ()

description and source-code

reset = function () {

    this._error = null;
}

example usage

...
return this._finalize();
    }

    if (exit) {                                             // Can be a valid response or error (if returned from an ext, already
 handled because this.response is also set)
this._setResponse(Response.wrap(exit, this));
    }

    this._protect.reset();

    const transmit = (err) => {

if (err) {                                          // Can be valid response or error
    this._setResponse(Response.wrap(err, this));
}
...

function hapi.protect.prototype.run (next, enter)

description and source-code

run = function (next, enter) {              // enter: function (exit)

    const finish = Hoek.once((arg0, arg1, arg2) => {

        this._error = null;
        return next(arg0, arg1, arg2);
    });

    if (this.domain) {
        this._error = (err) => {

            return finish(Boom.badImplementation('Uncaught error', err));
        };
    }

    return enter(finish);
}

example usage

...

            return next(setting === 'optional' ? null : Boom.unauthorized('Missing payload authentication'));
        }

        return next(response);
    };

    request._protect.run(finalize, (exit) => {

        const reply = request.server._replier.interface(request, strategy.realm, {}, exit);
        strategy.methods.payload(request, reply);
    });
};
...

module hapi.reply

function hapi.reply ()

description and source-code

reply = function () {

    this._decorations = null;
}

example usage
```
n/a
```

module hapi.reply.prototype

function hapi.reply.prototype.decorate (property, method)

description and source-code

decorate = function (property, method) {

    Hoek.assert(!this._decorations || !this._decorations[property], 'Reply interface decoration already defined:', property);
    Hoek.assert(['request', 'response', 'close', 'state', 'unstate', 'redirect', 'continue'].indexOf(property) === -1, 'Cannot override
 built-in reply interface decoration:', property);

    this._decorations = this._decorations || {};
    this._decorations[property] = method;
}

example usage
```
n/a
```

function hapi.reply.prototype.interface (request, realm, options, next)

description and source-code

interface = function (request, realm, options, next) {        // next(err || response, data);

    const reply = (err, response, data) => {

        Hoek.assert(data === undefined || options.data, 'Reply interface does not allow a third argument');

        reply._data = data;                 // Held for later
        return reply.response(err !== null && err !== undefined ? err : response);
    };

    reply._settings = options;
    reply._replied = false;
    reply._next = Hoek.once(next);

    reply.realm = realm;
    reply.request = request;

    reply.close = internals.close;
    reply.continue = internals.continue;
    reply.state = internals.state;
    reply.unstate = internals.unstate;
    reply.redirect = internals.redirect;
    reply.response = internals.response;
    reply.entity = internals.entity;

    if (this._decorations) {
        const methods = Object.keys(this._decorations);
        for (let i = 0; i < methods.length; ++i) {
            const method = methods[i];
            reply[method] = this._decorations[method];
        }
    }

    return reply;
}

example usage

...

internals.Auth.prototype.test = function (name, request, next) {

Hoek.assert(name, 'Missing authentication strategy name');
const strategy = this._strategies[name];
Hoek.assert(strategy, 'Unknown authentication strategy:', name);

const reply = request.server._replier.interface(request, strategy.realm, { data: true
 }, (response) => next(response, reply._data && reply._data.credentials));
strategy.methods.authenticate(request, reply);
};


internals.Auth.prototype._setupRoute = function (options, path) {

if (!options) {
...

module hapi.request

function hapi.request ()

description and source-code

request = function () {

    this._decorations = null;
}

example usage

...
            req.socket.end();
        }
    });
}

// Create request

const request = this.server._requestor.request(this, req, res, options);

// Check load

const overload = this._load.check();
if (overload) {
    this.server._log(['load'], this.server.load);
    request._reply(overload);
...

module hapi.request.prototype

function hapi.request.prototype.decorate (property, method, options)

description and source-code

decorate = function (property, method, options) {

    options = options || {};

    Hoek.assert(!this._decorations || this._decorations[property] === undefined, 'Request interface decoration already defined:',
property);
    Hoek.assert(internals.properties.indexOf(property) === -1, 'Cannot override built-in request interface decoration:', property
);

    this._decorations = this._decorations || {};
    this._decorations[property] = { method, apply: options.apply };
}

example usage
```
n/a
```

function hapi.request.prototype.request (connection, req, res, options)

description and source-code

request = function (connection, req, res, options) {

    const request = new internals.Request(connection, req, res, options);

    // Decorate

    if (this._decorations) {
        const properties = Object.keys(this._decorations);
        for (let i = 0; i < properties.length; ++i) {
            const property = properties[i];
            const assignment = this._decorations[property];
            request[property] = (assignment.apply ? assignment.method(request) : assignment.method);
        }
    }

    return request;
}

example usage

...
            req.socket.end();
        }
    });
}

// Create request

const request = this.server._requestor.request(this, req, res, options);

// Check load

const overload = this._load.check();
if (overload) {
    this.server._log(['load'], this.server.load);
    request._reply(overload);
...

module hapi.response

function hapi.response (source, request, options)

description and source-code

response = function (source, request, options) {

    Podium.call(this, ['finish', { name: 'peek', spread: true }]);

    options = options || {};

    this.request = request;
    this.statusCode = null;
    this.headers = {};                          // Incomplete as some headers are stored in flags
    this.variety = null;
    this.source = null;
    this.app = {};
    this.plugins = {};
    this.send = null;                           // Set by reply()
    this.hold = null;                           // Set by reply()

    this.settings = {
        encoding: 'utf8',
        charset: 'utf-8',                       // '-' required by IANA
        ttl: null,
        stringify: null,                        // JSON.stringify options
        passThrough: true,
        varyEtag: false,
        message: null
    };

    this._payload = null;                       // Readable stream
    this._takeover = false;
    this._contentEncoding = null;               // Set during transmit
    this._contentType = null;                   // Used if no explicit content-type is set and type is known
    this._error = null;                         // The boom object when created from an error

    this._processors = {
        marshal: options.marshal,
        prepare: options.prepare,
        close: options.close
    };

    this._setSource(source, options.variety);
}

example usage

...
if (!strategy.methods.response) {
    return next();
}

request._protect.run(next, (exit) => {

    const reply = request.server._replier.interface(request, strategy.realm, {}, exit);
    strategy.methods.response(request, reply);
});
};


internals.Authenticator = class {
constructor(config, request, manager) {
...

function hapi.response.Payload (payload, options)

description and source-code

Payload = function (payload, options) {

    Stream.Readable.call(this);
    this._data = payload;
    this._prefix = null;
    this._suffix = null;
    this._sizeOffset = 0;
    this._encoding = options.encoding;
}

example usage

...
        payload = payload + suffix;
    }
}
else if (this.settings.stringify) {
    return next(Boom.badImplementation('Cannot set formatting options on non object response'));
}

this._payload = new internals.Payload(payload, this.settings);
return next();
};


internals.Response.prototype._tap = function () {

return (this.hasListeners('finish') || this.hasListeners('peek') ? new internals.Peek(this) : null);
...

function hapi.response.Peek (podium)

description and source-code

Peek = function (podium) {

    Stream.Transform.call(this);
    this._podium = podium;
    this.once('finish', () => {

        podium.emit('finish');
    });
}

example usage

...

    this._states[name] = state;
};


internals.Request.prototype._tap = function () {

    return (this.hasListeners('finish') || this.hasListeners('peek') ? new Response.Peek(this) : null);
};


internals.Request.prototype.generateResponse = function (source, options) {

    return new Response(source, this, options);
};
...

function hapi.response.super_ (events)

description and source-code

super_ = function (events) {

    // Use descriptive names to avoid conflict when inherited

    this._eventListeners = Object.create(null);
    this._notificationsQueue = [];
    this._eventsProcessing = false;
    this._sourcePodiums = [];

    if (events) {
        this.registerEvent(events);
    }
}

example usage
```
n/a
```

function hapi.response.unmodified (request, options)

description and source-code

unmodified = function (request, options) {

    if (request.method !== 'get' &&
        request.method !== 'head') {

        return false;
    }

    // Strong verifier

    if (options.etag &&
        request.headers['if-none-match']) {

        const ifNoneMatch = request.headers['if-none-match'].split(/\s*,\s*/);
        for (let i = 0; i < ifNoneMatch.length; ++i) {
            const etag = ifNoneMatch[i];
            if (etag === options.etag) {
                return true;
            }

            if (options.vary) {
                const etagBase = options.etag.slice(0, -1);
                const encoders = request.connection._compression.encodings;
                for (let j = 0; j < encoders.length; ++j) {
                    if (etag === etagBase + `-${encoders[j]}"`) {
                        return true;
                    }
                }
            }
        }

        return false;
    }

    // Weak verifier

    const ifModifiedSinceHeader = request.headers['if-modified-since'];

    if (ifModifiedSinceHeader &&
        options.modified) {

        const ifModifiedSince = internals.parseDate(ifModifiedSinceHeader);
        const lastModified = internals.parseDate(options.modified);

        if (ifModifiedSince &&
            lastModified &&
            ifModifiedSince >= lastModified) {

            return true;
        }
    }

    return false;
}

example usage

...
internals.entity = function (options) {

    Hoek.assert(options, 'Entity method missing required options');
    Hoek.assert(options.etag || options.modified, 'Entity methods missing require options key');

    this.request._entity = options;

    if (Response.unmodified(this.request, options)) {
        return this.response().code(304).takeover();
    }

    return null;
};
...

function hapi.response.wrap (result, request)

description and source-code

wrap = function (result, request) {

    return (result instanceof Error ? Boom.wrap(result)
                                    : (result instanceof internals.Response ? result
                                                                            : new internals.Response(result, request)));
}

example usage

...

internals.handler = function (request, callback) {

    const timer = new Hoek.Bench();
    const finalize = (response) => {

if (response === null) {                            // reply.continue()
    response = Response.wrap(null, request);
    return response._prepare(finalize);
}

// Check for Error result

if (response.isBoom) {
    request._log(['handler', 'error'], { msec: timer.elapsed(), error: response.message, data: response });
...

module hapi.response.prototype

function hapi.response.prototype._close ()

description and source-code

_close = function () {

    if (this._processors.close) {
        this._processors.close(this);
    }

    const stream = this._payload || this.source;
    if (stream instanceof Stream) {
        if (stream.close) {
            stream.close();
        }
        else if (stream.destroy) {
            stream.destroy();
        }
        else {
            const read = () => {

                stream.read();
            };

            const end = () => {

                stream.removeListener('readable', read);
                stream.removeListener('error', end);
                stream.removeListener('end', end);
            };

            stream.on('readable', read);
            stream.once('error', end);
            stream.once('end', end);
        }
    }
}

example usage

...
    this.raw.req.removeListener('end', this._onEnd);
    this.raw.req.removeListener('close', this._onClose);
    this.raw.req.removeListener('error', this._onError);

    if (this.response &&
        this.response._close) {

        this.response._close();
    }

    this._protect.logger = this.server;
};


internals.Request.prototype._setResponse = function (response) {
...

function hapi.response.prototype._header (key, value, options)

description and source-code

_header = function (key, value, options) {

    options = options || {};
    const append = options.append || false;
    const separator = options.separator || ',';
    const override = options.override !== false;
    const duplicate = options.duplicate !== false;

    if ((!append && override) ||
        !this.headers[key]) {

        this.headers[key] = value;
    }
    else if (override) {
        if (key === 'set-cookie') {
            this.headers[key] = [].concat(this.headers[key], value);
        }
        else {
            const existing = this.headers[key];
            if (!duplicate) {
                const values = existing.split(separator);
                for (let i = 0; i < values.length; ++i) {
                    if (values[i] === value) {
                        return this;
                    }
                }
            }

            this.headers[key] = existing + separator + value;
        }
    }

    return this;
}

example usage

...
        return reply({ message: 'CORS error: Some headers are not allowed' });
    }
}

// Reply with the route CORS headers

const response = reply();
response._header('access-control-allow-origin', request.headers.origin);
response._header('access-control-allow-methods', method);
response._header('access-control-allow-headers', settings._headersString);
response._header('access-control-max-age', settings.maxAge);

if (settings.credentials) {
    response._header('access-control-allow-credentials', 'true');
}
...

function hapi.response.prototype._isPayloadSupported ()

description and source-code

_isPayloadSupported = function () {

    return (this.request.method !== 'head' && this.statusCode !== 304 && this.statusCode !== 204);
}

example usage

...
request._log(['state', 'response', 'error'], err);
request._states = {};                                           // Clear broken state
return next(err);
        }

        internals.cache(response);

        if (!response._isPayloadSupported() &&
request.method !== 'head') {

// Set empty stream

response._close();                                  // Close unused file streams
response._payload = new internals.Empty();
delete response.headers['content-length'];
...

function hapi.response.prototype._isRewritable ()

description and source-code

_isRewritable = function () {

    return this.statusCode === 301 || this.statusCode === 302;
}

example usage

...
return this.statusCode === 301 || this.statusCode === 302;
};


internals.Response.prototype._setTemporary = function (isTemporary) {

if (isTemporary) {
    if (this._isRewritable()) {
        this.statusCode = 302;
    }
    else {
        this.statusCode = 307;
    }
}
else {
...

function hapi.response.prototype._isTemporary ()

description and source-code

_isTemporary = function () {

    return this.statusCode === 302 || this.statusCode === 307;
}

example usage

...
}
};


internals.Response.prototype._setRewritable = function (isRewritable) {

if (isRewritable) {
    if (this._isTemporary()) {
        this.statusCode = 302;
    }
    else {
        this.statusCode = 301;
    }
}
else {
...

function hapi.response.prototype._marshal (next)

description and source-code

_marshal = function (next) {

    if (!this._processors.marshal) {
        return this._streamify(this.source, next);
    }

    this._processors.marshal(this, (err, source) => {

        if (err) {
            return next(err);
        }

        return this._streamify(source, next);
    });
}

example usage

...

response._close();                                  // Close unused file streams
response._payload = new internals.Empty();
delete response.headers['content-length'];
return Auth.response(request, next);                // Must be last in case requires access to headers
        }

        response._marshal((err) => {

if (err) {
    return next(Boom.wrap(err));
}

if (request.jsonp &&
    response._payload.jsonp) {
...

function hapi.response.prototype._passThrough ()

description and source-code

_passThrough = function () {

    if (this.variety === 'stream' &&
        this.settings.passThrough) {

        if (this.source.statusCode &&
            !this.statusCode) {

            this.statusCode = this.source.statusCode;                        // Stream is an HTTP response
        }

        if (this.source.headers) {
            let headerKeys = Object.keys(this.source.headers);

            if (headerKeys.length) {
                const localHeaders = this.headers;
                this.headers = {};

                for (let i = 0; i < headerKeys.length; ++i) {
                    const key = headerKeys[i];
                    this.header(key.toLowerCase(), Hoek.clone(this.source.headers[key]));     // Clone arrays
                }

                headerKeys = Object.keys(localHeaders);
                for (let i = 0; i < headerKeys.length; ++i) {
                    const key = headerKeys[i];
                    this.header(key, localHeaders[key], { append: key === 'set-cookie' });
                }
            }
        }
    }

    this.statusCode = this.statusCode || 200;
}

example usage

...
this._takeover = true;
return this;
};


internals.Response.prototype._prepare = function (next) {

this._passThrough();

if (this.variety !== 'promise') {
    return this._processPrepare(next);
}

const onDone = Hoek.nextTick((source) => {
...

function hapi.response.prototype._permanent (isPermanent)

description and source-code

_permanent = function (isPermanent) {

    this._setTemporary(isPermanent === false);           // Defaults to true
    return this;
}

example usage
```
n/a
```

function hapi.response.prototype._prepare (next)

description and source-code

_prepare = function (next) {

    this._passThrough();

    if (this.variety !== 'promise') {
        return this._processPrepare(next);
    }

    const onDone = Hoek.nextTick((source) => {

        if (source instanceof Error) {
            return next(Boom.wrap(source));
        }

        if (source instanceof internals.Response) {
            return source._processPrepare(next);
        }

        this._setSource(source);
        this._passThrough();
        this._processPrepare(next);
    });

    const onError = (source) => {

        if (!(source instanceof Error)) {
            const err = new Error('Rejected promise');
            err.data = source;
            return next(Boom.wrap(err));
        }

        return next(Boom.wrap(source));
    };

    this.source.then(onDone, onError);
}

example usage

...
internals.handler = function (request, callback) {

    const timer = new Hoek.Bench();
    const finalize = (response) => {

if (response === null) {                            // reply.continue()
    response = Response.wrap(null, request);
    return response._prepare(finalize);
}

// Check for Error result

if (response.isBoom) {
    request._log(['handler', 'error'], { msec: timer.elapsed(), error: response.message, data: response });
    return callback(response);
...

function hapi.response.prototype._processPrepare (next)

description and source-code

_processPrepare = function (next) {

    if (!this._processors.prepare) {
        return next(this);
    }

    return this._processors.prepare(this, next);
}

example usage

...


internals.Response.prototype._prepare = function (next) {

    this._passThrough();

    if (this.variety !== 'promise') {
return this._processPrepare(next);
    }

    const onDone = Hoek.nextTick((source) => {

if (source instanceof Error) {
    return next(Boom.wrap(source));
}
...

function hapi.response.prototype._rewritable (isRewritable)

description and source-code

_rewritable = function (isRewritable) {

    this._setRewritable(isRewritable !== false);         // Defaults to true
    return this;
}

example usage
```
n/a
```

function hapi.response.prototype._setRewritable (isRewritable)

description and source-code

_setRewritable = function (isRewritable) {

    if (isRewritable) {
        if (this._isTemporary()) {
            this.statusCode = 302;
        }
        else {
            this.statusCode = 301;
        }
    }
    else {
        if (this._isTemporary()) {
            this.statusCode = 307;
        }
        else {
            this.statusCode = 308;
        }
    }
}

example usage

...
this._setTemporary(isPermanent === false);           // Defaults to true
return this;
};


internals.Response.prototype._rewritable = function (isRewritable) {

this._setRewritable(isRewritable !== false);         // Defaults to true
return this;
};


internals.Response.prototype._isTemporary = function () {

return this.statusCode === 302 || this.statusCode === 307;
...

function hapi.response.prototype._setSource (source, variety)

description and source-code

_setSource = function (source, variety) {

    // Method must not set any headers or other properties as source can change later

    this.variety = variety || 'plain';

    if (source === null ||
        source === undefined ||
        source === '') {

        source = null;
    }
    else if (Buffer.isBuffer(source)) {
        this.variety = 'buffer';
        this._contentType = 'application/octet-stream';
    }
    else if (source instanceof Stream) {
        this.variety = 'stream';
    }
    else if (typeof source === 'object' &&
        typeof source.then === 'function') {                // Promise object

        this.variety = 'promise';
    }

    this.source = source;

    if (this.variety === 'plain' &&
        this.source !== null) {

        this._contentType = (typeof this.source === 'string' ? 'text/html' : 'application/json');
    }
}

example usage

...

    this._processors = {
        marshal: options.marshal,
        prepare: options.prepare,
        close: options.close
    };

    this._setSource(source, options.variety);
};

Hoek.inherits(internals.Response, Podium);


internals.Response.wrap = function (result, request) {
...

function hapi.response.prototype._setTemporary (isTemporary)

description and source-code

_setTemporary = function (isTemporary) {

    if (isTemporary) {
        if (this._isRewritable()) {
            this.statusCode = 302;
        }
        else {
            this.statusCode = 307;
        }
    }
    else {
        if (this._isRewritable()) {
            this.statusCode = 301;
        }
        else {
            this.statusCode = 308;
        }
    }
}

example usage

...
this.rewritable = this._rewritable;
return this;
};


internals.Response.prototype._temporary = function (isTemporary) {

this._setTemporary(isTemporary !== false);           // Defaults to true
return this;
};


internals.Response.prototype._permanent = function (isPermanent) {

this._setTemporary(isPermanent === false);           // Defaults to true
...

function hapi.response.prototype._streamify (source, next)

description and source-code

_streamify = function (source, next) {

    if (source instanceof Stream) {
        if (typeof source._read !== 'function' || typeof source._readableState !== 'object') {
            return next(Boom.badImplementation('Stream must have a streams2 readable interface'));
        }

        if (source._readableState.objectMode) {
            return next(Boom.badImplementation('Cannot reply with stream in object mode'));
        }

        this._payload = source;
        return next();
    }

    let payload = source;
    if (this.variety === 'plain' &&
        source !== null &&
        typeof source !== 'string') {

        const options = this.settings.stringify || {};
        const space = options.space || this.request.route.settings.json.space;
        const replacer = options.replacer || this.request.route.settings.json.replacer;
        const suffix = options.suffix || this.request.route.settings.json.suffix || '';
        try {
            if (replacer || space) {
                payload = JSON.stringify(payload, replacer, space);
            }
            else {
                payload = JSON.stringify(payload);
            }
        }
        catch (err) {
            return next(err);
        }

        if (suffix) {
            payload = payload + suffix;
        }
    }
    else if (this.settings.stringify) {
        return next(Boom.badImplementation('Cannot set formatting options on non object response'));
    }

    this._payload = new internals.Payload(payload, this.settings);
    return next();
}

example usage

...
    return this._processors.prepare(this, next);
};


internals.Response.prototype._marshal = function (next) {

    if (!this._processors.marshal) {
return this._streamify(this.source, next);
    }

    this._processors.marshal(this, (err, source) => {

if (err) {
    return next(err);
}
...

function hapi.response.prototype._tap ()

description and source-code

_tap = function () {

    return (this.hasListeners('finish') || this.hasListeners('peek') ? new internals.Peek(this) : null);
}

example usage

...
if (failAction === 'error') {
    return next(err);
}

return next();
    };

    Subtext.parse(request.raw.req, request._tap(), request.route.settings.payload, (err
, parsed) => {

if (!err ||
    !request._isPayloadPending) {

    request._isPayloadPending = false;
    return onParsed(err, parsed);
}
...

function hapi.response.prototype._temporary (isTemporary)

description and source-code

_temporary = function (isTemporary) {

    this._setTemporary(isTemporary !== false);           // Defaults to true
    return this;
}

example usage
```
n/a
```

function hapi.response.prototype.bytes (bytes)

description and source-code

bytes = function (bytes) {

    this._header('content-length', bytes);
    return this;
}

example usage

...

            // Prepare transform

            if (ranges.length === 1) {                                          // Ignore requests for multiple ranges
                const range = ranges[0];
                ranger = new Ammo.Stream(range);
                response.code(206);
                response.bytes(range.to - range.from + 1);
                response._header('content-range', 'bytes ' + range.from + '-' + range.to + '/&#
x27; + length);
            }
        }
    }

    response._header('accept-ranges', 'bytes');
}
...

function hapi.response.prototype.charset (charset)

description and source-code

charset = function (charset) {

    this.settings.charset = charset || null;
    return this;
}

example usage
```
n/a
```

function hapi.response.prototype.code (statusCode)

description and source-code

code = function (statusCode) {

    Hoek.assert(Hoek.isInteger(statusCode), 'Status code must be an integer');

    this.statusCode = statusCode;
    return this;
}

example usage

...

    Hoek.assert(options, 'Entity method missing required options');
    Hoek.assert(options.etag || options.modified, 'Entity methods missing require options key');

    this.request._entity = options;

    if (Response.unmodified(this.request, options)) {
        return this.response().code(304).takeover();
    }

    return null;
};
...

function hapi.response.prototype.created (location)

description and source-code

created = function (location) {

    Hoek.assert(this.request.method === 'post' || this.request.method === 'put', 'Cannot create resource on GET');

    this.statusCode = 201;
    this.location(location);
    return this;
}

example usage
```
n/a
```

function hapi.response.prototype.encoding (encoding)

description and source-code

encoding = function (encoding) {

    this.settings.encoding = encoding;
    return this;
}

example usage

...
Hoek.assert(typeof decoder === 'function', `Invalid decoder function for ${encoding}`);
this._decoders[encoding] = decoder;
};


internals.Compression.prototype.accept = function (request) {

return Accept.encoding(request.headers['accept-encoding'], this.encodings);
};


internals.Compression.prototype.encoding = function (response) {

const request = response.request;
if (!request.connection.settings.compression) {
...

function hapi.response.prototype.etag (tag, options)

description and source-code

etag = function (tag, options) {

    Hoek.assert(tag !== '*', 'ETag cannot be *');

    options = options || {};
    this._header('etag', (options.weak ? 'W/' : '') + '"' + tag + '"');
    this.settings.varyEtag = options.vary !== false && !options.weak;       // vary defaults to true
    return this;
}

example usage

...
const request = response.request;

// Set headers from reply.entity()

if (request._entity.etag &&
    !response.headers.etag) {

    response.etag(request._entity.etag, { vary: request._entity.vary });
}

if (request._entity.modified &&
    !response.headers['last-modified']) {

    response.header('last-modified', request._entity.modified);
}
...

function hapi.response.prototype.header (key, value, options)

description and source-code

header = function (key, value, options) {

    key = key.toLowerCase();
    if (key === 'vary') {
        return this.vary(value);
    }

    return this._header(key, value, options);
}

example usage

...

            if (headerKeys.length) {
const localHeaders = this.headers;
this.headers = {};

for (let i = 0; i < headerKeys.length; ++i) {
    const key = headerKeys[i];
    this.header(key.toLowerCase(), Hoek.clone(this.source.headers[key]));     // Clone
 arrays
}

headerKeys = Object.keys(localHeaders);
for (let i = 0; i < headerKeys.length; ++i) {
    const key = headerKeys[i];
    this.header(key, localHeaders[key], { append: key === 'set-cookie' });
}
...

function hapi.response.prototype.location (uri)

description and source-code

location = function (uri) {

    this._header('location', uri);
    return this;
}

example usage

...


internals.Response.prototype.created = function (location) {

Hoek.assert(this.request.method === 'post' || this.request.method === 'put', 'Cannot create resource on
 GET');

this.statusCode = 201;
this.location(location);
return this;
};


internals.Response.prototype.replacer = function (method) {

this.settings.stringify = this.settings.stringify || {};
...

function hapi.response.prototype.message (httpMessage)

description and source-code

message = function (httpMessage) {

    this.settings.message = httpMessage;
    return this;
}

example usage
```
n/a
```

function hapi.response.prototype.passThrough (enabled)

description and source-code

passThrough = function (enabled) {

    this.settings.passThrough = (enabled !== false);    // Defaults to true
    return this;
}

example usage
```
n/a
```

function hapi.response.prototype.redirect (location)

description and source-code

redirect = function (location) {

    this.statusCode = 302;
    this.location(location);
    this.temporary = this._temporary;
    this.permanent = this._permanent;
    this.rewritable = this._rewritable;
    return this;
}

example usage

...

this.request._clearState(name, options);
};


internals.redirect = function (location) {

return this.response('').redirect(location);
};


internals.response = function (result) {

Hoek.assert(!this._replied, 'reply interface called twice');
this._replied = true;
...

function hapi.response.prototype.replacer (method)

description and source-code

replacer = function (method) {

    this.settings.stringify = this.settings.stringify || {};
    this.settings.stringify.replacer = method;
    return this;
}

example usage
```
n/a
```

function hapi.response.prototype.spaces (count)

description and source-code

spaces = function (count) {

    this.settings.stringify = this.settings.stringify || {};
    this.settings.stringify.space = count;
    return this;
}

example usage
```
n/a
```

function hapi.response.prototype.state (name, value, options)

description and source-code

state = function (name, value, options) {          // options: see Defaults.state

    this.request._setState(name, value, options);
    return this;
}

example usage

...
    const response = request.response;

    Cors.headers(response);
    internals.content(response, false);
    internals.security(response);
    internals.unmodified(response);

    internals.state(response, (err) => {

if (err) {
    request._log(['state', 'response', 'error'], err);
    request._states = {};                                           // Clear broken state
    return next(err);
}
...

function hapi.response.prototype.suffix (suffix)

description and source-code

suffix = function (suffix) {

    this.settings.stringify = this.settings.stringify || {};
    this.settings.stringify.suffix = suffix;
    return this;
}

example usage
```
n/a
```

function hapi.response.prototype.takeover ()

description and source-code

takeover = function () {

    this._takeover = true;
    return this;
}

example usage

...
};


/*
    const handler = function (request, reply) {

reply(error, result, ignore);   -> error || result (continue)
reply(...).takeover();          -> ... (continue)

reply.continue(ignore);         -> null (continue)
    };

    const ext = function (request, reply) {

reply(error, result, ignore);   -> error || result (respond)
...

function hapi.response.prototype.ttl (ttl)

description and source-code

ttl = function (ttl) {

    this.settings.ttl = ttl;
    return this;
}

example usage

...
    const policy = request.route.settings.cache &&
                   request._route._cache &&
                   (request.route.settings.cache._statuses[response.statusCode] || (response.statusCode === 304 && request
.route.settings.cache._statuses['200']));

    if (policy ||
        response.settings.ttl) {

        const ttl = (response.settings.ttl !== null ? response.settings.ttl : request._route._cache.ttl());
        const privacy = (request.auth.isAuthenticated || response.headers['set-cookie'] ? 'private' : request
.route.settings.cache.privacy || 'default');
        response._header('cache-control', 'max-age=' + Math.floor(ttl / 1000) + ', must-revalidate'
; + (privacy !== 'default' ? ', ' + privacy : ''));
    }
    else if (request.route.settings.cache) {
        response._header('cache-control', request.route.settings.cache.otherwise);
    }
};
...

function hapi.response.prototype.type (type)

description and source-code

type = function (type) {

    this._header('content-type', type);
    return this;
}

example usage

...
internals.Compression.prototype.encoding = function (response) {

const request = response.request;
if (!request.connection.settings.compression) {
    return null;
}

const mime = request.server.mime.type(response.headers['content-type'] || &#
x27;application/octet-stream');
if (!mime.compressible) {
    return null;
}

response.vary('accept-encoding');

if (response.headers['content-encoding']) {
...

function hapi.response.prototype.unstate (name, options)

description and source-code

unstate = function (name, options) {

    this.request._clearState(name, options);
    return this;
}

example usage
```
n/a
```

function hapi.response.prototype.vary (value)

description and source-code

vary = function (value) {

    if (value === '*') {
        this.headers.vary = '*';
    }
    else if (!this.headers.vary) {
        this.headers.vary = value;
    }
    else if (this.headers.vary !== '*') {
        this._header('vary', value, { append: true, duplicate: false });
    }

    return this;
}

example usage

...
    }

    const mime = request.server.mime.type(response.headers['content-type'] || 'application/octet-stream');
    if (!mime.compressible) {
        return null;
    }

    response.vary('accept-encoding');

    if (response.headers['content-encoding']) {
        return null;
    }

    return (request.info.acceptEncoding === 'identity' ? null : request.info.acceptEncoding);
};
...

module hapi.route

function hapi.route (route, connection, plugin, options)

description and source-code

route = function (route, connection, plugin, options) {

    options = options || {};

    // Apply plugin environment (before schema validation)

    const realm = plugin.realm;
    if (realm.modifiers.route.vhost ||
        realm.modifiers.route.prefix) {

        route = Hoek.cloneWithShallow(route, ['config']);       // config is left unchanged
        route.path = (realm.modifiers.route.prefix ? realm.modifiers.route.prefix + (route.path !== '/' ? route.path : '') : route
.path);
        route.vhost = realm.modifiers.route.vhost || route.vhost;
    }

    // Setup and validate route configuration

    Hoek.assert(route.path, 'Route missing path');
    const routeDisplay = route.method + ' ' + route.path;

    let config = route.config;
    if (typeof config === 'function') {
        config = config.call(realm.settings.bind, connection.server);
    }

    Hoek.assert(route.handler || (config && config.handler), 'Missing or undefined handler:', routeDisplay);
    Hoek.assert(!!route.handler ^ !!(config && config.handler), 'Handler must only appear once:', routeDisplay);            // XOR
    Hoek.assert(route.path === '/' || route.path[route.path.length - 1] !== '/' || !connection.settings.router.stripTrailingSlash
, 'Path cannot end with a trailing slash when connection configured to strip:', routeDisplay);

    route = Schema.apply('route', route, routeDisplay);

    const handler = route.handler || config.handler;
    const method = route.method.toLowerCase();
    Hoek.assert(method !== 'head', 'Method name not allowed:', routeDisplay);

    // Apply settings in order: {connection} <- {handler} <- {realm} <- {route}

    const handlerDefaults = Handler.defaults(method, handler, connection.server);
    let base = Hoek.applyToDefaultsWithShallow(connection.settings.routes, handlerDefaults, ['bind']);
    base = Hoek.applyToDefaultsWithShallow(base, realm.settings, ['bind']);
    this.settings = Hoek.applyToDefaultsWithShallow(base, config || {}, ['bind', 'validate.headers', 'validate.payload', 'validate
.params', 'validate.query']);
    this.settings.handler = handler;
    this.settings = Schema.apply('routeConfig', this.settings, routeDisplay);

    const socketTimeout = (this.settings.timeout.socket === undefined ? 2 * 60 * 1000 : this.settings.timeout.socket);
    Hoek.assert(!this.settings.timeout.server || !socketTimeout || this.settings.timeout.server < socketTimeout, 'Server timeout
 must be shorter than socket timeout:', routeDisplay);
    Hoek.assert(!this.settings.payload.timeout || !socketTimeout || this.settings.payload.timeout < socketTimeout, 'Payload timeout
 must be shorter than socket timeout:', routeDisplay);

    this.connection = connection;
    this.server = connection.server;
    this.path = route.path;
    this.method = method;
    this.plugin = plugin;

    this.settings.vhost = route.vhost;
    this.settings.plugins = this.settings.plugins || {};            // Route-specific plugins settings, namespaced using plugin
name
    this.settings.app = this.settings.app || {};                    // Route-specific application settings

    // Path parsing

    this._special = !!options.special;
    this._analysis = this.connection._router.analyze(this.path);
    this.params = this._analysis.params;
    this.fingerprint = this._analysis.fingerprint;

    this.public = {
        method: this.method,
        path: this.path,
        vhost: this.vhost,
        realm: this.plugin.realm,
        settings: this.settings,
        fingerprint: this.fingerprint,
        auth: {
            access: (request) => Auth.access(request, this.public)
        }
    };

    // Validation

    const validation = this.settings.validate;
    if (this.method === 'get') {

        // Assert on config, not on merged settings

        Hoek.assert(!config || !config.payload, 'Cannot set payload settings on HEAD or GET request:', routeDisplay);
        Hoek.assert(!config || !config.validate || !config.validate.payload, 'Cannot validate HEAD or GET requests:', routeDisplay
);

        validation.payload = null;
    }

    ['headers', ' ...

example usage

...

internals.Connection.prototype.match = function (method, path, host) {

    Hoek.assert(method && typeof method === 'string', 'Invalid method:', method);
    Hoek.assert(path && typeof path === 'string' && path[0] === '/', 'Invalid path:&#
x27;, path);
    Hoek.assert(!host || typeof host === 'string', 'Invalid host:', host);

    const match = this._router.route(method.toLowerCase(), path, host);
    Hoek.assert(match !== this._router.specials.badRequest, 'Invalid path:', path);
    if (match === this._router.specials.notFound) {
        return null;
    }

    return match.route.public;
};
...

module hapi.route.prototype

function hapi.route.prototype._combineExtensions (type, subscribe)

description and source-code

_combineExtensions = function (type, subscribe) {

    const ext = new Ext(type, this.server);

    const events = this.settings.ext[type];
    if (events) {
        for (let i = 0; i < events.length; ++i) {
            const event = Hoek.shallow(events[i]);
            Hoek.assert(!event.options.sandbox, 'Cannot specify sandbox option for route extension');
            event.plugin = this.plugin;
            ext.add(event);
        }
    }

    const connection = this.connection._extensions[type];
    const realm = this.plugin.realm._extensions[type];

    ext.merge([connection, realm]);

    connection.subscribe(this);
    realm.subscribe(this);

    return ext;
}

example usage

...

this.settings.handler = Handler.configure(this.settings.handler, this);
this._prerequisites = Handler.prerequisitesConfig(this.settings.pre, this.server);

// Route lifecycle

this._extensions = {
    onPreResponse: this._combineExtensions('onPreResponse')
};

if (this._special) {
    this._cycle = [Handler.execute];
    return;
}
...

function hapi.route.prototype.rebuild (event)

description and source-code

rebuild = function (event) {

    if (event) {
        this._extensions[event.type].add(event);
        if (event.type === 'onPreResponse') {
            return;
        }
    }

    // Build lifecycle array

    const cycle = [];

    // 'onRequest'

    if (this.settings.jsonp) {
        cycle.push(internals.parseJSONP);
    }

    if (this.settings.state.parse) {
        cycle.push(internals.state);
    }

    if (this._extensions.onPreAuth.nodes) {
        cycle.push(this._extensions.onPreAuth);
    }

    const authenticate = (this.settings.auth !== false);                          // Anything other than 'false' can still require
 authentication
    if (authenticate) {
        cycle.push(Auth.authenticate);
    }

    if (this.method !== 'get') {
        cycle.push(internals.payload);

        if (authenticate) {
            cycle.push(Auth.payload);
        }
    }

    if (this._extensions.onPostAuth.nodes) {
        cycle.push(this._extensions.onPostAuth);
    }

    if (this.settings.validate.headers) {
        cycle.push(Validation.headers);
    }

    if (this.settings.validate.params) {
        cycle.push(Validation.params);
    }

    if (this.settings.jsonp) {
        cycle.push(internals.cleanupJSONP);
    }

    if (this.settings.validate.query) {
        cycle.push(Validation.query);
    }

    if (this.settings.validate.payload) {
        cycle.push(Validation.payload);
    }

    if (this._extensions.onPreHandler.nodes) {
        cycle.push(this._extensions.onPreHandler);
    }

    cycle.push(Handler.execute);                                     // Must not call next() with an Error

    if (this._extensions.onPostHandler.nodes) {
        cycle.push(this._extensions.onPostHandler);                 // An error from here on will override any result set in handler
()
    }

    if (this.settings.response._validate &&
        this.settings.response.sample !== 0) {

        cycle.push(Validation.response);
    }

    this._cycle = cycle;
}

example usage

...
}

this.nodes = this._topo.nodes;

// Notify routes

for (let i = 0; i < this._routes.length; ++i) {
    this._routes[i].rebuild(event);
}
};


internals.Ext.prototype.merge = function (others) {

const merge = [];
...

module hapi.schema

function hapi.schema.apply (type, options, message)

description and source-code

apply = function (type, options, message) {

    const result = Joi.validate(options, internals[type]);
    Hoek.assert(!result.error, 'Invalid', type, 'options', message ? '(' + message + ')' : '', result.error && result.error.annotate
());
    return result.value;
}

example usage

...
    }
};


internals.Auth.prototype.default = function (options) {

    Hoek.assert(!this.settings.default, 'Cannot set default strategy more than once');
    options = Schema.apply('auth', options, 'default strategy');

    this.settings.default = this._setupRoute(Hoek.clone(options));      // Can change options
};


internals.Auth.prototype.test = function (name, request, next) {
...

module hapi.transmit

function hapi.transmit.send (request, callback)

description and source-code

send = function (request, callback) {

    const response = request.response;
    if (response.isBoom) {
        return internals.fail(request, response, callback);
    }

    internals.marshal(request, (err) => {

        if (err) {
            request._setResponse(err);
            return internals.fail(request, err, callback);
        }

        return internals.transmit(response, (err) => {

            if (err) {
                request._setResponse(err);
                return internals.fail(request, err, callback);
            }

            return callback();
        });
    });
}

example usage

...

const transmit = (err) => {

    if (err) {                                          // Can be valid response or error
        this._setResponse(Response.wrap(err, this));
    }

    return Transmit.send(this, () => this._finalize());
};

if (!this._route._extensions.onPreResponse.nodes) {
    return transmit();
}

return this._invoke(this._route._extensions.onPreResponse, transmit);
...

module hapi.validation

function hapi.validation.compile (rule)

description and source-code

compile = function (rule) {

    // null, undefined, true - anything allowed
    // false - nothing allowed
    // {...} - ... allowed

    return (rule === false ? Joi.object({}).allow(null)
                           : typeof rule === 'function' ? rule
                                                        : !rule || rule === true ? null                     // false tested earlier
                                                                                 : Joi.compile(rule));
}

example usage

...
Hoek.assert(!config || !config.validate || !config.validate.payload, 'Cannot validate HEAD or GET requests:', routeDisplay
);

validation.payload = null;
    }

    ['headers', 'params', 'query', 'payload'].forEach((type) => {

validation[type] = Validation.compile(validation[type]);
    });

    if (this.settings.response.schema !== undefined ||
this.settings.response.status) {

this.settings.response._validate = true;
...

function hapi.validation.headers (request, next)

description and source-code

headers = function (request, next) {

    return internals.input('headers', request, next);
}

example usage

...
};


internals.marshal = function (request, next) {

    const response = request.response;

    Cors.headers(response);
    internals.content(response, false);
    internals.security(response);
    internals.unmodified(response);

    internals.state(response, (err) => {

if (err) {
...

function hapi.validation.params (request, next)

description and source-code

params = function (request, next) {

    return internals.input('params', request, next);
}

example usage
```
n/a
```

function hapi.validation.payload (request, next)

description and source-code

payload = function (request, next) {

    if (request.method === 'get' ||
        request.method === 'head') {                // When route.method is '*'

        return next();
    }

    return internals.input('payload', request, next);
}

example usage

...

    return next(response);
};

request._protect.run(finalize, (exit) => {

    const reply = request.server._replier.interface(request, strategy.realm, {}, exit);
    strategy.methods.payload(request, reply);
});
};


internals.Auth.response = function (request, next) {

const auth = request.connection.auth;
...

function hapi.validation.query (request, next)

description and source-code

query = function (request, next) {

    return internals.input('query', request, next);
}

example usage
```
n/a
```

function hapi.validation.response (request, next)

description and source-code

response = function (request, next) {

    if (request.route.settings.response.sample) {
        const currentSample = Math.ceil((Math.random() * 100));
        if (currentSample > request.route.settings.response.sample) {
            return next();
        }
    }

    const response = request.response;
    const statusCode = response.isBoom ? response.output.statusCode : response.statusCode;

    const statusSchema = request.route.settings.response.status[statusCode];
    if (statusCode >= 400 &&
        !statusSchema) {

        return next();          // Do not validate errors by default
    }

    const schema = statusSchema || request.route.settings.response.schema;
    if (schema === null) {
        return next();          // No rules
    }

    if (!response.isBoom &&
        request.response.variety !== 'plain') {

        return next(Boom.badImplementation('Cannot validate non-object response'));
    }

    const postValidate = (err, value) => {

        if (!err) {
            if (value !== undefined &&
                request.route.settings.response.modify) {

                if (response.isBoom) {
                    response.output.payload = value;
                }
                else {
                    response.source = value;
                }
            }

            return next();
        }

        // failAction: 'error', 'log'

        if (request.route.settings.response.failAction === 'log') {
            request._log(['validation', 'response', 'error'], err.message);
            return next();
        }

        // Return error

        if (typeof request.route.settings.response.failAction !== 'function') {
            return next(Boom.badImplementation(err.message));
        }

        // Custom handler

        request._protect.run(next, (exit) => {

            const reply = request.server._replier.interface(request, request.route.realm, {}, exit);
            request.route.settings.response.failAction(request, reply, err);
        });
    };

    const localOptions = {
        context: {
            headers: request.headers,
            params: request.params,
            query: request.query,
            payload: request.payload,
            auth: {
                isAuthenticated: request.auth.isAuthenticated,
                credentials: request.auth.credentials
            }
        }
    };

    const source = response.isBoom ? response.output.payload : response.source;
    Hoek.merge(localOptions, request.route.settings.response.options);

    if (typeof schema !== 'function') {
        return Joi.validate(source, schema, localOptions, postValidate);
    }

    request._protect.run(postValidate, (exit) => {

        return schema(source, localOptions, exit);
    });
}

example usage

...
if (!strategy.methods.response) {
    return next();
}

request._protect.run(next, (exit) => {

    const reply = request.server._replier.interface(request, strategy.realm, {}, exit);
    strategy.methods.response(request, reply);
});
};


internals.Authenticator = class {
constructor(config, request, manager) {
...

api documentation for hapi (v16.1.0)

HTTP Server framework

table of contents