You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
120 lines
3.4 KiB
120 lines
3.4 KiB
'use strict'
|
|
const path = require('path')
|
|
const http = require('http')
|
|
const url = require('url')
|
|
const arrayify = require('array-back')
|
|
const pathToRegexp = require('path-to-regexp')
|
|
const debug = require('debug')('local-web-server')
|
|
|
|
/**
|
|
* @module middleware
|
|
*/
|
|
exports.proxyRequest = proxyRequest
|
|
exports.blacklist = blacklist
|
|
exports.mockResponses = mockResponses
|
|
exports.mime = mime
|
|
|
|
function proxyRequest (route, app) {
|
|
const httpProxy = require('http-proxy')
|
|
const proxy = httpProxy.createProxyServer({
|
|
changeOrigin: true
|
|
})
|
|
|
|
return function * proxyMiddleware () {
|
|
const next = arguments[arguments.length - 1]
|
|
const keys = []
|
|
route.re = pathToRegexp(route.from, keys)
|
|
route.new = this.url.replace(route.re, route.to)
|
|
|
|
keys.forEach((key, index) => {
|
|
const re = RegExp(`:${key.name}`, 'g')
|
|
route.new = route.new
|
|
.replace(re, arguments[index] || '')
|
|
})
|
|
|
|
/* test no keys remain in the new path */
|
|
keys.length = 0
|
|
pathToRegexp(url.parse(route.new).path, keys)
|
|
if (keys.length) {
|
|
this.throw(500, `[PROXY] Invalid target URL: ${route.new}`)
|
|
return next()
|
|
}
|
|
|
|
this.response = false
|
|
debug('proxy request', `from: ${this.path}, to: ${url.parse(route.new).href}`)
|
|
|
|
proxy.once('error', err => {
|
|
this.throw(500, `[PROXY] ${err.message}: ${route.new}`)
|
|
})
|
|
proxy.once('proxyReq', function (proxyReq) {
|
|
proxyReq.path = url.parse(route.new).path
|
|
})
|
|
proxy.web(this.req, this.res, { target: route.new })
|
|
}
|
|
}
|
|
|
|
function blacklist (forbid) {
|
|
return function blacklist (ctx, next) {
|
|
if (forbid.some(expression => pathToRegexp(expression).test(ctx.path))) {
|
|
ctx.throw(403, http.STATUS_CODES[403])
|
|
} else {
|
|
return next()
|
|
}
|
|
}
|
|
}
|
|
|
|
function mockResponses (options) {
|
|
options = options || { root: process.cwd() }
|
|
return function mockResponses (ctx, next) {
|
|
if (/\.mock.js$/.test(ctx.path)) {
|
|
const mocks = arrayify(require(path.join(options.root, ctx.path)))
|
|
const testValue = require('test-value')
|
|
const t = require('typical')
|
|
|
|
/* find a mock with compatible method and accepts */
|
|
let mock = mocks.find(mock => {
|
|
return testValue(mock, {
|
|
request: {
|
|
method: [ ctx.method, undefined ],
|
|
accepts: type => ctx.accepts(type)
|
|
}
|
|
})
|
|
})
|
|
|
|
/* else take the first mock without a request (no request means 'all requests') */
|
|
if (!mock) {
|
|
mock = mocks.find(mock => !mock.request)
|
|
}
|
|
|
|
const mockedReponse = {}
|
|
/* resolve any functions on the mock */
|
|
Object.keys(mock.response).forEach(key => {
|
|
if (t.isFunction(mock.response[key])) {
|
|
mockedReponse[key] = mock.response[key](ctx)
|
|
} else {
|
|
mockedReponse[key] = mock.response[key]
|
|
}
|
|
})
|
|
|
|
if (mock) {
|
|
Object.assign(ctx.response, mockedReponse)
|
|
// debug('mocked response', JSON.stringify(mockedReponse))
|
|
// debug('actual response', JSON.stringify(ctx.response))
|
|
}
|
|
} else {
|
|
return next()
|
|
}
|
|
}
|
|
}
|
|
|
|
function mime (mimeTypes) {
|
|
return function mime (ctx, next) {
|
|
return next().then(() => {
|
|
const reqPathExtension = path.extname(ctx.path).slice(1)
|
|
Object.keys(mimeTypes).forEach(mimeType => {
|
|
const extsToOverride = mimeTypes[mimeType]
|
|
if (extsToOverride.indexOf(reqPathExtension) > -1) ctx.type = mimeType
|
|
})
|
|
})
|
|
}
|
|
}
|