Initial import from local backup (Documents-Playground/pakerpale)

node_modules/express-http-proxy/app/steps/buildProxyReq.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var debug = require('debug')('express-http-proxy');
+var requestOptions = require('../../lib/requestOptions');
+
+function buildProxyReq(Container) {
+  var req = Container.user.req;
+  var res = Container.user.res;
+  var options = Container.options;
+  var host = Container.proxy.host;
+
+  var parseBody = (!options.parseReqBody) ? Promise.resolve(null) : requestOptions.bodyContent(req, res, options);
+  var createReqOptions = requestOptions.create(req, res, options, host);
+
+  return Promise
+    .all([parseBody, createReqOptions])
+    .then(function(responseArray) {
+      Container.proxy.bodyContent = responseArray[0];
+      Container.proxy.reqBuilder = responseArray[1];
+      debug('proxy request options:', Container.proxy.reqBuilder);
+      return Container;
+    });
+}
+
+module.exports = buildProxyReq;

node_modules/express-http-proxy/app/steps/copyProxyResHeadersToUserRes.js

@@ -0,0 +1,22 @@
+'use strict';
+
+function copyProxyResHeadersToUserRes(container) {
+  return new Promise(function(resolve) {
+    var res = container.user.res;
+    var rsp = container.proxy.res;
+
+    if (!res.headersSent) {
+        res.status(rsp.statusCode);
+        Object.keys(rsp.headers)
+        .filter(function(item) { return item !== 'transfer-encoding'; })
+        .forEach(function(item) {
+            res.set(item, rsp.headers[item]);
+        });
+    }
+
+    resolve(container);
+  });
+}
+
+module.exports = copyProxyResHeadersToUserRes;
+

node_modules/express-http-proxy/app/steps/decorateProxyReqBody.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var debug = require('debug')('express-http-proxy');
+
+function defaultDecorator(proxyReqOptBody/*, userReq */) {
+  return proxyReqOptBody;
+}
+
+function decorateProxyReqBody(container) {
+  var userDecorator = container.options.proxyReqBodyDecorator;
+  var resolverFn = userDecorator || defaultDecorator;
+
+  if (userDecorator) {
+    debug('using custom proxyReqBodyDecorator');
+  }
+
+  return Promise
+    .resolve(resolverFn(container.proxy.bodyContent, container.user.req))
+    .then(function(bodyContent) {
+      container.proxy.bodyContent = bodyContent;
+      return Promise.resolve(container);
+    });
+}
+
+module.exports = decorateProxyReqBody;

node_modules/express-http-proxy/app/steps/decorateProxyReqOpts.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var debug = require('debug')('express-http-proxy');
+
+function defaultDecorator(proxyReqOptBuilder /*, userReq */) {
+  return proxyReqOptBuilder;
+}
+
+function decorateProxyReqOpt(container) {
+  var resolverFn = container.options.proxyReqOptDecorator || defaultDecorator;
+
+  return Promise
+    .resolve(resolverFn(container.proxy.reqBuilder, container.user.req))
+    .then(function (processedReqOpts) {
+      delete processedReqOpts.params;
+      container.proxy.reqBuilder = processedReqOpts;
+      debug('Request options (after processing): %o', processedReqOpts);
+      return Promise.resolve(container);
+    });
+}
+
+module.exports = decorateProxyReqOpt;

node_modules/express-http-proxy/app/steps/decorateUserRes.js

@@ -0,0 +1,66 @@
+'use strict';
+
+var as = require('../../lib/as.js');
+var debug = require('debug')('express-http-proxy');
+var zlib = require('zlib');
+
+function isResGzipped(res) {
+  return res.headers['content-encoding'] === 'gzip';
+}
+
+function zipOrUnzip(method) {
+  return function(rspData, res) {
+    return (isResGzipped(res) && rspData.length) ? zlib[method](rspData) : rspData;
+  };
+}
+
+var maybeUnzipResponse = zipOrUnzip('gunzipSync');
+var maybeZipResponse = zipOrUnzip('gzipSync');
+
+function verifyBuffer(rspd, reject) {
+  if (!Buffer.isBuffer(rspd)) {
+    return reject(new Error('userResDecorator should return string or buffer as data'));
+  }
+}
+
+function updateHeaders(res, rspdBefore, rspdAfter, reject) {
+  if (!res.headersSent) {
+      res.set('content-length', rspdAfter.length);
+  } else if (rspdAfter.length !== rspdBefore.length) {
+      var error = '"Content-Length" is already sent,' +
+          'the length of response data can not be changed';
+      return reject(new Error(error));
+  }
+}
+
+function decorateProxyResBody(container) {
+  var resolverFn = container.options.userResDecorator;
+
+  if (!resolverFn) {
+    return Promise.resolve(container);
+  }
+
+  var proxyResData = maybeUnzipResponse(container.proxy.resData, container.proxy.res);
+  var proxyRes = container.proxy.res;
+  var req = container.user.req;
+  var res = container.user.res;
+
+  if (res.statusCode === 304) {
+    debug('Skipping userResDecorator on response 304');
+    return Promise.resolve(container);
+  }
+
+  return Promise
+    .resolve(resolverFn(proxyRes, proxyResData, req, res))
+    .then(function(modifiedResData) {
+      return new Promise(function(resolve, reject) {
+        var rspd = as.buffer(modifiedResData, container.options);
+        verifyBuffer(rspd, reject);
+        updateHeaders(res, proxyResData, rspd, reject);
+        container.proxy.resData = maybeZipResponse(rspd, container.proxy.res);
+        resolve(container);
+      });
+    });
+}
+
+module.exports = decorateProxyResBody;

node_modules/express-http-proxy/app/steps/decorateUserResHeaders.js

@@ -0,0 +1,22 @@
+'use strict';
+
+
+function decorateUserResHeaders(container) {
+  var resolverFn = container.options.userResHeaderDecorator;
+  var headers = container.user.res._headers;
+
+  if (!resolverFn) {
+    return Promise.resolve(container);
+  }
+
+  return Promise
+    .resolve(resolverFn(headers, container.user.req, container.user.res, container.proxy.req, container.proxy.res))
+    .then(function(headers) {
+      return new Promise(function(resolve) {
+        container.user.res.set(headers);
+        resolve(container);
+      });
+    });
+}
+
+module.exports = decorateUserResHeaders;

node_modules/express-http-proxy/app/steps/filterUserRequest.js

@@ -0,0 +1,24 @@
+'use strict';
+
+// No-op version of filter.  Allows everything!
+
+function defaultFilter(proxyReqOptBuilder, userReq) { // eslint-disable-line
+  return true;
+}
+
+function filterUserRequest(container) {
+  var resolverFn = container.options.filter || defaultFilter;
+
+  return Promise
+    .resolve(resolverFn(container.user.req, container.user.res))
+    .then(function (shouldIContinue) {
+      if (shouldIContinue) {
+        return Promise.resolve(container);
+      } else {
+        return Promise.reject(); // reject with no args should simply call next()
+      }
+    });
+}
+
+module.exports = filterUserRequest;
+

node_modules/express-http-proxy/app/steps/handleProxyErrors.js

@@ -0,0 +1,21 @@
+'use strict';
+
+var debug = require('debug')('express-http-proxy');
+
+function connectionResetHandler(err, res) {
+  if (err && err.code === 'ECONNRESET') {
+    debug('Error: Connection reset due to timeout.');
+    res.setHeader('X-Timeout-Reason', 'express-http-proxy reset the request.');
+    res.writeHead(504, {'Content-Type': 'text/plain'});
+    res.end();
+  }
+}
+
+function handleProxyErrors(err, res, next) {
+  switch (err && err.code) {
+    case 'ECONNRESET':  { return connectionResetHandler(err, res, next); }
+    default:            { next(err); }
+  }
+}
+
+module.exports = handleProxyErrors;

node_modules/express-http-proxy/app/steps/maybeSkipToNextHandler.js

@@ -0,0 +1,22 @@
+'use strict';
+
+function defaultSkipFilter(/* res */) {
+  return false;
+}
+
+function maybeSkipToNextHandler(container) {
+  var resolverFn = container.options.skipToNextHandlerFilter || defaultSkipFilter;
+
+  return Promise
+    .resolve(resolverFn(container.proxy.res))
+    .then(function (shouldSkipToNext) {
+      if (shouldSkipToNext) {
+        container.user.res.expressHttpProxy = container.proxy;
+        return Promise.reject(container.user.next());
+      } else {
+        return Promise.resolve(container);
+      }
+    })
+}
+
+module.exports = maybeSkipToNextHandler;

node_modules/express-http-proxy/app/steps/prepareProxyReq.js

@@ -0,0 +1,40 @@
+'use strict';
+
+var as = require('../../lib/as');
+
+function getContentLength(body) {
+
+  var result;
+  if (Buffer.isBuffer(body)) { // Buffer
+    result = body.length;
+  } else if (typeof body === 'string') {
+    result = Buffer.byteLength(body);
+  }
+  return result;
+}
+
+
+function prepareProxyReq(container) {
+  return new Promise(function(resolve) {
+    var bodyContent = container.proxy.bodyContent;
+    var reqOpt = container.proxy.reqBuilder;
+
+    if (bodyContent) {
+      bodyContent = container.options.reqAsBuffer ?
+        as.buffer(bodyContent, container.options) :
+        as.bufferOrString(bodyContent);
+
+      reqOpt.headers['content-length'] = getContentLength(bodyContent);
+
+      if (container.options.reqBodyEncoding) {
+        reqOpt.headers['Accept-Charset'] = container.options.reqBodyEncoding;
+      }
+    }
+
+    container.proxy.bodyContent = bodyContent;
+    resolve(container);
+  });
+}
+
+module.exports = prepareProxyReq;
+

node_modules/express-http-proxy/app/steps/resolveProxyHost.js

@@ -0,0 +1,19 @@
+'use strict';
+var requestOptions = require('../../lib/requestOptions');
+
+function resolveProxyHost(container) {
+  var parsedHost;
+
+  if (container.options.memoizeHost && container.options.memoizedHost) {
+    parsedHost = container.options.memoizedHost;
+  } else {
+    parsedHost = requestOptions.parseHost(container);
+  }
+
+  container.proxy.reqBuilder.host = parsedHost.host;
+  container.proxy.reqBuilder.port = container.options.port || parsedHost.port;
+  container.proxy.requestModule = parsedHost.module;
+  return Promise.resolve(container);
+}
+
+module.exports = resolveProxyHost;

node_modules/express-http-proxy/app/steps/resolveProxyReqPath.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var url = require('url');
+var debug = require('debug')('express-http-proxy');
+
+function defaultProxyReqPathResolver(req) {
+  return url.parse(req.url).path;
+}
+
+function resolveProxyReqPath(container) {
+  var resolverFn = container.options.proxyReqPathResolver || defaultProxyReqPathResolver;
+
+  return Promise
+    .resolve(resolverFn(container.user.req))
+    .then(function(resolvedPath) {
+      container.proxy.reqBuilder.path = resolvedPath;
+      debug('resolved proxy path:', resolvedPath);
+      return Promise.resolve(container);
+    });
+}
+
+module.exports = resolveProxyReqPath;

node_modules/express-http-proxy/app/steps/sendProxyRequest.js

@@ -0,0 +1,78 @@
+'use strict';
+
+var chunkLength = require('../../lib/chunkLength');
+
+function sendProxyRequest(Container) {
+  var req = Container.user.req;
+  var bodyContent = Container.proxy.bodyContent;
+  var reqOpt = Container.proxy.reqBuilder;
+  var options = Container.options;
+
+  return new Promise(function(resolve, reject) {
+    var protocol = Container.proxy.requestModule;
+    var proxyReq = Container.proxy.req = protocol.request(reqOpt, function(rsp) {
+      if (options.stream) {
+        Container.proxy.res = rsp;
+        return resolve(Container);
+      }
+
+      var chunks = [];
+      rsp.on('data', function(chunk) { chunks.push(chunk); });
+      rsp.on('end', function() {
+        Container.proxy.res = rsp;
+        Container.proxy.resData = Buffer.concat(chunks, chunkLength(chunks));
+        resolve(Container);
+      });
+      rsp.on('error', reject);
+    });
+
+    proxyReq.on('socket', function(socket) {
+      if (options.timeout) {
+        socket.setTimeout(options.timeout, function() {
+          proxyReq.abort();
+        });
+      }
+    });
+
+    proxyReq.on('error', reject);
+
+    // this guy should go elsewhere, down the chain
+    if (options.parseReqBody) {
+    // We are parsing the body ourselves so we need to write the body content
+    // and then manually end the request.
+
+      //if (bodyContent instanceof Object) {
+        //throw new Error
+        //debugger;
+        //bodyContent = JSON.stringify(bodyContent);
+      //}
+
+      if (bodyContent.length) {
+        var body = bodyContent;
+        var contentType = proxyReq.getHeader('Content-Type');
+        if (contentType === 'x-www-form-urlencoded' || contentType === 'application/x-www-form-urlencoded') {
+          try {
+            var params = JSON.parse(body);
+            body = Object.keys(params).map(function(k) { return k + '=' + params[k]; }).join('&');
+          } catch (e) {
+            // bodyContent is not json-format
+          }
+        }
+        proxyReq.setHeader('Content-Length', Buffer.byteLength(body));
+        proxyReq.write(body);
+      }
+      proxyReq.end();
+    } else {
+    // Pipe will call end when it has completely read from the request.
+      req.pipe(proxyReq);
+    }
+
+    req.on('aborted', function() {
+    // reject?
+      proxyReq.abort();
+    });
+  });
+}
+
+
+module.exports = sendProxyRequest;

node_modules/express-http-proxy/app/steps/sendUserRes.js

@@ -0,0 +1,15 @@
+'use strict';
+
+function sendUserRes(Container) {
+  if (!Container.user.res.headersSent) {
+    if (Container.options.stream) {
+      Container.proxy.res.pipe(Container.user.res);
+    } else {
+      Container.user.res.send(Container.proxy.resData);
+    }
+  }
+  return Promise.resolve(Container);
+}
+
+
+module.exports = sendUserRes;