Forked expressjs/vhost to vhost-middleware

no issue

Direct copy of current master from https://github.com/expressjs/vhost/ with automatic eslint fixes to match our styleguide.

Forked because we need a reverse proxy fix and the original module appears abandoned.

Author: kevinansfield

ghost/vhost-middleware/.eslintrc.js

@@ -0,0 +1,6 @@
+module.exports = {
+    plugins: ['ghost'],
+    extends: [
+        'plugin:ghost/node',
+    ]
+};

ghost/vhost-middleware/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Ghost Foundation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ghost/vhost-middleware/README.md

@@ -0,0 +1,179 @@
+# Vhost Middleware
+
+Forked from https://github.com/expressjs/vhost/ which appears abandoned.
+
+## Install
+
+`npm install @tryghost/vhost-middleware --save`
+
+or
+
+`yarn add @tryghost/vhost-middleware`
+
+
+## API
+
+<!-- eslint-disable no-unused-vars -->
+
+```js
+var vhost = require('vhost')
+```
+
+### vhost(hostname, handle)
+
+Create a new middleware function to hand off request to `handle` when the incoming
+host for the request matches `hostname`. The function is called as
+`handle(req, res, next)`, like a standard middleware.
+
+`hostname` can be a string or a RegExp object. When `hostname` is a string it can
+contain `*` to match 1 or more characters in that section of the hostname. When
+`hostname` is a RegExp, it will be forced to case-insensitive (since hostnames are)
+and will be forced to match based on the start and end of the hostname.
+
+When host is matched and the request is sent down to a vhost handler, the `req.vhost`
+property will be populated with an object. This object will have numeric properties
+corresponding to each wildcard (or capture group if RegExp object provided) and the
+`hostname` that was matched.
+
+```js
+var connect = require('connect')
+var vhost = require('vhost')
+var app = connect()
+
+app.use(vhost('*.*.example.com', function handle (req, res, next) {
+  // for match of "foo.bar.example.com:8080" against "*.*.example.com":
+  console.dir(req.vhost.host) // => 'foo.bar.example.com:8080'
+  console.dir(req.vhost.hostname) // => 'foo.bar.example.com'
+  console.dir(req.vhost.length) // => 2
+  console.dir(req.vhost[0]) // => 'foo'
+  console.dir(req.vhost[1]) // => 'bar'
+}))
+```
+
+## Examples
+
+### using with connect for static serving
+
+```js
+var connect = require('connect')
+var serveStatic = require('serve-static')
+var vhost = require('vhost')
+
+var mailapp = connect()
+
+// add middlewares to mailapp for mail.example.com
+
+// create app to serve static files on subdomain
+var staticapp = connect()
+staticapp.use(serveStatic('public'))
+
+// create main app
+var app = connect()
+
+// add vhost routing to main app for mail
+app.use(vhost('mail.example.com', mailapp))
+
+// route static assets for "assets-*" subdomain to get
+// around max host connections limit on browsers
+app.use(vhost('assets-*.example.com', staticapp))
+
+// add middlewares and main usage to app
+
+app.listen(3000)
+```
+
+### using with connect for user subdomains
+
+```js
+var connect = require('connect')
+var serveStatic = require('serve-static')
+var vhost = require('vhost')
+
+var mainapp = connect()
+
+// add middlewares to mainapp for the main web site
+
+// create app that will server user content from public/{username}/
+var userapp = connect()
+
+userapp.use(function (req, res, next) {
+  var username = req.vhost[0] // username is the "*"
+
+  // pretend request was for /{username}/* for file serving
+  req.originalUrl = req.url
+  req.url = '/' + username + req.url
+
+  next()
+})
+userapp.use(serveStatic('public'))
+
+// create main app
+var app = connect()
+
+// add vhost routing for main app
+app.use(vhost('userpages.local', mainapp))
+app.use(vhost('www.userpages.local', mainapp))
+
+// listen on all subdomains for user pages
+app.use(vhost('*.userpages.local', userapp))
+
+app.listen(3000)
+```
+
+### using with any generic request handler
+
+```js
+var connect = require('connect')
+var http = require('http')
+var vhost = require('vhost')
+
+// create main app
+var app = connect()
+
+app.use(vhost('mail.example.com', function (req, res) {
+  // handle req + res belonging to mail.example.com
+  res.setHeader('Content-Type', 'text/plain')
+  res.end('hello from mail!')
+}))
+
+// an external api server in any framework
+var httpServer = http.createServer(function (req, res) {
+  res.setHeader('Content-Type', 'text/plain')
+  res.end('hello from the api!')
+})
+
+app.use(vhost('api.example.com', function (req, res) {
+  // handle req + res belonging to api.example.com
+  // pass the request to a standard Node.js HTTP server
+  httpServer.emit('request', req, res)
+}))
+
+app.listen(3000)
+```
+
+
+## Develop
+
+This is a mono repository, managed with [lerna](https://lernajs.io/).
+
+Follow the instructions for the top-level repo.
+1. `git clone` this repo & `cd` into it as usual
+2. Run `yarn` to install top-level dependencies.
+
+
+## Run
+
+- `yarn dev`
+
+
+## Test
+
+- `yarn lint` run just eslint
+- `yarn test` run lint and tests
+
+
+
+
+# Copyright & License
+
+Copyright (c) 2019 Ghost Foundation - Released under the [MIT license](LICENSE).

ghost/vhost-middleware/index.js

@@ -0,0 +1,164 @@
+/*!
+ * vhost
+ * Copyright(c) 2014 Jonathan Ong
+ * Copyright(c) 2014-2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+'use strict';
+
+/**
+ * Module exports.
+ * @public
+ */
+
+module.exports = vhost;
+
+/**
+ * Module variables.
+ * @private
+ */
+
+var ASTERISK_REGEXP = /\*/g;
+var ASTERISK_REPLACE = '([^.]+)';
+var END_ANCHORED_REGEXP = /(?:^|[^\\])(?:\\\\)*\$$/;
+var ESCAPE_REGEXP = /([.+?^=!:${}()|[\]/\\])/g;
+var ESCAPE_REPLACE = '\\$1';
+
+/**
+ * Create a vhost middleware.
+ *
+ * @param {string|RegExp} hostname
+ * @param {function} handle
+ * @return {Function}
+ * @public
+ */
+
+function vhost(hostname, handle) {
+    if (!hostname) {
+        throw new TypeError('argument hostname is required');
+    }
+
+    if (!handle) {
+        throw new TypeError('argument handle is required');
+    }
+
+    if (typeof handle !== 'function') {
+        throw new TypeError('argument handle must be a function');
+    }
+
+    // create regular expression for hostname
+    var regexp = hostregexp(hostname);
+
+    return function vhost(req, res, next) {
+        var vhostdata = vhostof(req, regexp);
+
+        if (!vhostdata) {
+            return next();
+        }
+
+        // populate
+        req.vhost = vhostdata;
+
+        // handle
+        handle(req, res, next);
+    };
+}
+
+/**
+ * Get hostname of request.
+ *
+ * @param (object} req
+ * @return {string}
+ * @private
+ */
+
+function hostnameof(req) {
+    var host = req.headers.host;
+
+    if (!host) {
+        return;
+    }
+
+    var offset = host[0] === '['
+        ? host.indexOf(']') + 1
+        : 0;
+    var index = host.indexOf(':', offset);
+
+    return index !== -1
+        ? host.substring(0, index)
+        : host;
+}
+
+/**
+ * Determine if object is RegExp.
+ *
+ * @param (object} val
+ * @return {boolean}
+ * @private
+ */
+
+function isregexp(val) {
+    return Object.prototype.toString.call(val) === '[object RegExp]';
+}
+
+/**
+ * Generate RegExp for given hostname value.
+ *
+ * @param (string|RegExp} val
+ * @private
+ */
+
+function hostregexp(val) {
+    var source = !isregexp(val)
+        ? String(val).replace(ESCAPE_REGEXP, ESCAPE_REPLACE).replace(ASTERISK_REGEXP, ASTERISK_REPLACE)
+        : val.source;
+
+    // force leading anchor matching
+    if (source[0] !== '^') {
+        source = '^' + source;
+    }
+
+    // force trailing anchor matching
+    if (!END_ANCHORED_REGEXP.test(source)) {
+        source += '$';
+    }
+
+    return new RegExp(source, 'i');
+}
+
+/**
+ * Get the vhost data of the request for RegExp
+ *
+ * @param (object} req
+ * @param (RegExp} regexp
+ * @return {object}
+ * @private
+ */
+
+function vhostof(req, regexp) {
+    var host = req.headers.host;
+    var hostname = hostnameof(req);
+
+    if (!hostname) {
+        return;
+    }
+
+    var match = regexp.exec(hostname);
+
+    if (!match) {
+        return;
+    }
+
+    var obj = Object.create(null);
+
+    obj.host = host;
+    obj.hostname = hostname;
+    obj.length = match.length - 1;
+
+    for (var i = 1; i < match.length; i++) {
+        obj[i - 1] = match[i];
+    }
+
+    return obj;
+}