@tryghost/mw-vhost 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2013-2025 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.

package/README.md

@@ -0,0 +1,147 @@
+# Vhost Middleware
+
+Forked from https://github.com/expressjs/vhost/ which appears abandoned.
+
+## 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.
+
+Where the `hostname` of the request comes from depends on the type of server you're running.
+If you're running a raw Node.js/connect server, this comes from [`req.headers.host`](https://nodejs.org/dist/latest/docs/api/http.html#http_message_headers).
+If you're running an express v4 server, this comes from [`req.hostname`](http://expressjs.com/en/4x/api.html#req.hostname).
+
+```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)
+```

package/index.js

@@ -0,0 +1 @@
+module.exports = require('./lib/vhost');

package/lib/vhost.js

@@ -0,0 +1,171 @@
+// This a fork of expressjs/vhost with trust proxy support
+/* eslint-disable */
+
+/*!
+ * 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 {import('express').RequestHandler}
+ * @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.hostname || // express v4
+        req.host || // express v3
+        req.headers.host; // http
+
+    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;
+}

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@tryghost/mw-vhost",
+  "version": "1.0.0",
+  "author": "Ghost Foundation",
+  "license": "MIT",
+  "main": "index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "dev": "echo \"Implement me!\"",
+    "test:unit": "NODE_ENV=testing c8 --all --reporter text --reporter cobertura -- mocha --reporter dot './test/**/*.test.js'",
+    "test": "yarn test:unit",
+    "lint:code": "eslint *.js lib/ --ext .js --cache",
+    "lint": "yarn lint:code && yarn lint:test",
+    "lint:test": "eslint -c test/.eslintrc.js test/ --ext .js --cache"
+  },
+  "files": [
+    "index.js",
+    "lib"
+  ],
+  "devDependencies": {
+    "c8": "8.0.1",
+    "mocha": "10.8.2",
+    "supertest": "6.3.4"
+  },
+  "gitHead": "feac71f0032c5d92f56a8dfa7ccd5a2d883ad53d"
+}