const common = require('./common');
const ContentNegotiation = require('./content-negotiation');
const Enum = require('./enum');
-const { DingusError, ResponseError } = require('./errors');
+const { ResponseError, RouterNoPathError, RouterNoMethodError } = require('./errors');
const { extensionToMime } = require('./mime-helper');
const Router = require('./router');
const Template = require('./template');
const _fileScope = common.fileScope(__filename);
const defaultOptions = {
- ignoreTrailingSlash: false,
+ ignoreTrailingSlash: true,
proxyPrefix: '',
strictAccept: true,
selfBaseUrl: '',
staticMetadata: true,
staticPath: undefined, // No reasonable default
trustProxy: true,
+ intrinsicHeadMethod: true,
+ intrinsicHeadPersistBody: false,
querystring,
};
/**
* @param {Object} logger object which implements logging methods
* @param {Object} options
- * @param {Boolean} options.ignoreTrailingSlash
+ * @param {Boolean} options.ignoreTrailingSlash requests for '/foo/' will match a '/foo' route
* @param {string} options.proxyPrefix leading part of url path to strip
* @param {Boolean} options.strictAccept whether to error on unsupported Accept type
* @param {string} options.selfBaseUrl for constructing links
* @param {Boolean} options.staticMetadata serve static headers with static files
* @param {Boolean} options.trustProxy trust some header data to be provided by proxy
+ * @param {Boolean} options.intrinsicHeadMethod handle HEAD requests automatically if not specified as a route method
+ * @param {Boolean} options.intrinsicHeadPersistBody include un-sent body on ctx for automatic HEAD requests
* @param {Object} options.querystring alternate qs parser to use
*/
- constructor(logger = common.nullLogger, options = {}) {
+ constructor(logger = console, options = {}) {
common.setOptions(this, defaultOptions, options);
this.router = new Router(options);
/**
- * Dispatch the handler for a request
- * @param {http.ClientRequest} req
- * @param {http.ServerResponse} res
- * @param {object} ctx
+ * Resolve the handler to invoke for a request.
+ * @param {http.ClientRequest} req
+ * @param {http.ServerResponse} res
+ * @param {object} ctx
+ * @returns {object}
*/
- async dispatch(req, res, ctx = {}) {
- const _scope = _fileScope('dispatch');
+ _determineHandler(req, res, ctx) {
+ const _scope = _fileScope('_determineHandler');
const { pathPart, queryParams } = this._splitUrl(req.url);
ctx.queryParams = queryParams;
try {
({ handler, handlerArgs } = this.router.lookup(req.method, pathPart, ctx));
} catch (e) {
- if (e instanceof DingusError) {
- switch (e.message) {
- case 'NoPath':
- handler = this.handlerNotFound.bind(this);
- break;
- case 'NoMethod':
- handler = this.handlerMethodNotAllowed.bind(this);
- break;
- default:
- this.logger.error(_scope, 'unknown dingus error', { error: e });
- handler = this.handlerInternalServerError.bind(this);
- }
- } else if (e instanceof URIError) {
+ if (e instanceof URIError) {
handler = this.handlerBadRequest.bind(this);
+ } else if (e instanceof RouterNoPathError) {
+ handler = this.handlerNotFound.bind(this);
+ } else if (e instanceof RouterNoMethodError) {
+ if (this.intrinsicHeadMethod && req.method === 'HEAD') {
+ ({ handler, handlerArgs } = this._determineHeadHandler(req, res, ctx, pathPart));
+ } else {
+ handler = this.handlerMethodNotAllowed.bind(this);
+ }
+ } else {
+ this.logger.error(_scope, 'unexpected error', { error: e });
+ handler = this.handlerInternalServerError.bind(this);
+ }
+ }
+ return { handler, handlerArgs };
+ }
+
+
+ /**
+ * For intrinsic HEAD requests, resolve the handler to invoke.
+ * @param {http.ClientRequest} req
+ * @param {http.ServerResponse} res
+ * @param {object} ctx
+ * @param {string} pathPart
+ * @returns {object}
+ */
+ _determineHeadHandler(req, res, ctx, pathPart) {
+ const _scope = _fileScope('_determineHeadHandler');
+ let handler, handlerArgs = [];
+ try {
+ ({ handler, handlerArgs } = this.router.lookup('GET', pathPart, ctx));
+ Dingus.setHeadHandler(req, res, ctx, this.intrinsicHeadPersistBody);
+ } catch (e) {
+ if (e instanceof RouterNoMethodError) {
+ handler = this.handlerMethodNotAllowed.bind(this);
} else {
- this.logger.error(_scope, 'lookup failure', { error: e });
+ this.logger.error(_scope, 'unexpected error', { error: e });
handler = this.handlerInternalServerError.bind(this);
}
}
+ return { handler, handlerArgs };
+ }
+
+ /**
+ * Dispatch the handler for a request
+ * @param {http.ClientRequest} req
+ * @param {http.ServerResponse} res
+ * @param {object} ctx
+ */
+ async dispatch(req, res, ctx = {}) {
+ const { handler, handlerArgs } = this._determineHandler(req, res, ctx);
try {
await this.preHandler(req, res, ctx);
return await handler(req, res, ctx, ...handlerArgs);
* Parse rawBody as contentType into ctx.parsedBody.
* @param {string} contentType
* @param {object} ctx
- * @param {string|buffer}
+ * @param {string|buffer} rawBody
*/
parseBody(contentType, ctx, rawBody) {
const _scope = _fileScope('parseBody');
- if (!rawBody) {
- // 1.2.4 and earlier expected rawBody on context
- rawBody = ctx.rawBody;
- }
-
switch (contentType) {
case Enum.ContentType.ApplicationForm:
ctx.parsedBody = this.querystring.parse(rawBody);