cloudcms-server 0.9.270 → 0.9.271

package/temp/node-http-proxy/lib/http-proxy/index.ts

@@ -0,0 +1,242 @@
+import http, {
+  IncomingMessage,
+  Server as HttpServer,
+  ServerResponse,
+} from 'http';
+import https from 'https';
+import { Duplex } from 'stream';
+import { parse as parse_url } from 'url';
+import EE3 from 'eventemitter3';
+import web from './passes/web-incoming';
+import ws from './passes/ws-incoming';
+import { ServerOptions } from '../types';
+
+interface PassInterface {
+  (this: ProxyServerNew, req: IncomingMessage, res: ServerResponse):
+    | boolean
+    | void;
+  (this: ProxyServerNew, req: IncomingMessage, res: Duplex, head: Buffer):
+    | boolean
+    | void;
+  (
+    this: ProxyServerNew,
+    req: IncomingMessage,
+    res: ServerResponse,
+    options: ServerOptions,
+    head: Buffer,
+    server: ProxyServerNew,
+    errorCallback: (
+      err: Error,
+      req: IncomingMessage,
+      res: ServerResponse,
+      url: ServerOptions['target'],
+    ) => void,
+  ): boolean | void;
+}
+
+/**
+ * Returns a function that creates the loader for
+ * either `ws` or `web`'s  passes.
+ *
+ * Examples:
+ *
+ *    createRightProxy('ws')
+ *    // => [Function]
+ *
+ * @param type
+ *
+ * @return Loader function that when called returns an iterator for the right passes
+ *
+ * @api private
+ */
+function createRightProxy(type: 'web' | 'ws') {
+  return function (options: ServerOptions) {
+    return function (
+      this: ProxyServerNew,
+      req: IncomingMessage,
+      resOrSocket: ServerResponse | Duplex,
+    ): void {
+      const passes = type === 'ws' ? this.wsPasses : this.webPasses,
+        // TODO: Migrate away from arguments.
+        // eslint-disable-next-line prefer-rest-params
+        args = [].slice.call(arguments) as any[];
+      let cntr = args.length - 1,
+        head,
+        cbl;
+
+      /* optional args parse begin */
+      if (typeof args[cntr] === 'function') {
+        cbl = args[cntr];
+
+        cntr--;
+      }
+
+      let requestOptions = options;
+      if (!(args[cntr] instanceof Buffer) && args[cntr] !== resOrSocket) {
+        //Copy global options
+        requestOptions = Object.assign({}, options);
+        //Overwrite with request options
+        Object.assign(requestOptions, args[cntr]);
+
+        cntr--;
+      }
+
+      if (args[cntr] instanceof Buffer) {
+        head = args[cntr];
+      }
+
+      /* optional args parse end */
+
+      (['target', 'forward'] as const).forEach(function (e) {
+        if (typeof requestOptions[e] === 'string')
+          requestOptions[e] = parse_url(requestOptions[e] as string);
+      });
+
+      if (!requestOptions.target && !requestOptions.forward) {
+        this.emit('error', new Error('Must provide a proper URL as target'));
+        return;
+      }
+
+      for (let i = 0; i < passes.length; i++) {
+        /**
+         * Call of passes functions
+         * pass(req, res, options, head)
+         *
+         * In WebSockets case the `res` variable
+         * refer to the connection socket
+         * pass(req, socket, options, head)
+         */
+        // TODO: Figure out the typing here.
+        // @ts-ignore
+        if (passes[i](req, resOrSocket, requestOptions, head, this, cbl)) {
+          // passes can return a truthy value to halt the loop
+          break;
+        }
+      }
+    };
+  };
+}
+
+export class ProxyServerNew extends EE3 {
+  options: ServerOptions;
+  web: PassInterface;
+  ws: PassInterface;
+  webPasses: PassInterface[];
+  wsPasses: PassInterface[];
+
+  _server: HttpServer | undefined;
+
+  constructor(options: ServerOptions) {
+    super();
+    options = options || {};
+    options.prependPath = options.prependPath !== false;
+
+    this.web = createRightProxy('web')(options);
+    this.ws = createRightProxy('ws')(options);
+    this.options = options;
+
+    this.webPasses = Object.keys(web).map(function (pass) {
+      // TODO: Figure out the typing here.
+      return web[pass as keyof typeof web] as PassInterface;
+    });
+
+    this.wsPasses = Object.keys(ws).map(function (pass) {
+      // TODO: Figure out the typing here.
+      return ws[pass as keyof typeof ws] as PassInterface;
+    });
+
+    this.on('error', this.onError, this);
+  }
+
+  after(type: 'web' | 'ws', passName: string, callback: PassInterface) {
+    const passes = type === 'ws' ? this.wsPasses : this.webPasses;
+    let i = -1;
+
+    passes.forEach((v, idx) => {
+      if (v.name === passName) i = idx;
+    });
+
+    if (i === -1) throw new Error('No such pass');
+
+    passes.splice(i++, 0, callback);
+  }
+
+  before(type: 'web' | 'ws', passName: string, callback: PassInterface) {
+    const passes = type === 'ws' ? this.wsPasses : this.webPasses;
+    let i = -1;
+
+    passes.forEach((v, idx) => {
+      if (v.name === passName) i = idx;
+    });
+
+    if (i === -1) throw new Error('No such pass');
+
+    passes.splice(i, 0, callback);
+  }
+
+  close(callback?: () => void) {
+    if (this._server) {
+      this._server.close(() => {
+        this._server = undefined;
+        callback?.();
+      });
+    }
+  }
+
+  listen(port: number, hostname: string) {
+    const closure = (req: IncomingMessage, res: ServerResponse) => {
+      this.web(req, res);
+    };
+
+    const server = this.options.ssl
+      ? https.createServer(this.options.ssl, closure)
+      : http.createServer(closure);
+
+    if (this.options.ws) {
+      server.on(
+        'upgrade',
+        (req: IncomingMessage, socket: Duplex, head: Buffer) => {
+          this.ws(req, socket, head);
+        },
+      );
+    }
+
+    server.listen(port, hostname);
+
+    this._server = server;
+
+    return this;
+  }
+
+  onError(err: Error) {
+    //
+    // Remark: Replicate node core behavior using EE3
+    // so we force people to handle their own errors
+    //
+    if (super.listeners('error').length === 1) {
+      throw err;
+    }
+  }
+}
+
+/**
+ * Creates the proxy server.
+ *
+ * Examples:
+ *
+ *    httpProxy.createServer({ .. }, 8000)
+ *    // => '{ web: [Function], ws: [Function] ... }'
+ *
+ * @param options Config object passed to the proxy
+ *
+ * @return Proxy object with handlers for `ws` and `web` requests
+ *
+ * @api public
+ */
+export function createProxyServer(options: ServerOptions) {
+  return new ProxyServerNew(options);
+}
+
+export const createProxy = createProxyServer;
+
+export const createServer = createProxyServer;

package/temp/node-http-proxy/lib/http-proxy/passes/web-incoming.js

@@ -0,0 +1,208 @@
+const httpNative = require('http'),
+  httpsNative = require('https'),
+  common = require('../common'),
+  followRedirects = require('follow-redirects'),
+  web_o = Object.values(require('./web-outgoing'));
+
+const nativeAgents = { http: httpNative, https: httpsNative };
+
+/*!
+ * Array of passes.
+ *
+ * A `pass` is just a function that is executed on `req, res, options`
+ * so that you can easily add new checks while still keeping the base
+ * flexible.
+ */
+
+module.exports = {
+  /**
+   * Sets `content-length` to '0' if request is of DELETE type.
+   *
+   * @param {ClientRequest} req Request object
+   * @param {IncomingMessage} res Response object
+   * @param {object} options Config object passed to the proxy
+   *
+   * @api private
+   */
+
+  deleteLength: function deleteLength(req, res, options) {
+    if (
+      (req.method === 'DELETE' || req.method === 'OPTIONS') &&
+      !req.headers['content-length']
+    ) {
+      req.headers['content-length'] = '0';
+      delete req.headers['transfer-encoding'];
+    }
+  },
+
+  /**
+   * Sets timeout in request socket if it was specified in options.
+   *
+   * @param {ClientRequest} req Request object
+   * @param {IncomingMessage} res Response object
+   * @param {object} options Config object passed to the proxy
+   *
+   * @api private
+   */
+
+  timeout: function timeout(req, res, options) {
+    if (options.timeout) {
+      req.socket.setTimeout(options.timeout);
+    }
+  },
+
+  /**
+   * Sets `x-forwarded-*` headers if specified in config.
+   *
+   * @param {ClientRequest} req Request object
+   * @param {IncomingMessage} res Response object
+   * @param {object} options Config object passed to the proxy
+   *
+   * @api private
+   */
+
+  XHeaders: function XHeaders(req, res, options) {
+    if (!options.xfwd) return;
+
+    const encrypted = req.isSpdy || common.hasEncryptedConnection(req);
+    const values = {
+      for: req.connection.remoteAddress || req.socket.remoteAddress,
+      port: common.getPort(req),
+      proto: encrypted ? 'https' : 'http',
+    };
+
+    ['for', 'port', 'proto'].forEach(function (header) {
+      req.headers['x-forwarded-' + header] =
+        (req.headers['x-forwarded-' + header] || '') +
+        (req.headers['x-forwarded-' + header] ? ',' : '') +
+        values[header];
+    });
+
+    req.headers['x-forwarded-host'] =
+      req.headers['x-forwarded-host'] || req.headers['host'] || '';
+  },
+
+  /**
+   * Does the actual proxying. If `forward` is enabled fires up
+   * a ForwardStream, same happens for ProxyStream. The request
+   * just dies otherwise.
+   *
+   * @param {ClientRequest} req Request object
+   * @param {IncomingMessage} res Response object
+   * @param {object} options Config object passed to the proxy
+   *
+   * @api private
+   */
+
+  stream: function stream(req, res, options, _, server, clb) {
+    // And we begin!
+    server.emit('start', req, res, options.target || options.forward);
+
+    const agents = options.followRedirects ? followRedirects : nativeAgents;
+    const http = agents.http;
+    const https = agents.https;
+
+    if (options.forward) {
+      // If forward enable, so just pipe the request
+      const forwardReq = (
+        options.forward.protocol === 'https:' ? https : http
+      ).request(
+        common.setupOutgoing(options.ssl || {}, options, req, 'forward'),
+      );
+
+      // error handler (e.g. ECONNRESET, ECONNREFUSED)
+      // Handle errors on incoming request as well as it makes sense to
+      const forwardError = createErrorHandler(forwardReq, options.forward);
+      req.on('error', forwardError);
+      forwardReq.on('error', forwardError);
+
+      (options.buffer || req).pipe(forwardReq);
+      if (!options.target) {
+        return res.end();
+      }
+    }
+
+    // Request initalization
+    const proxyReq = (
+      options.target.protocol === 'https:' ? https : http
+    ).request(common.setupOutgoing(options.ssl || {}, options, req));
+
+    // Enable developers to modify the proxyReq before headers are sent
+    proxyReq.on('socket', function (socket) {
+      if (server && !proxyReq.getHeader('expect')) {
+        server.emit('proxyReq', proxyReq, req, res, options);
+      }
+    });
+
+    // allow outgoing socket to timeout so that we could
+    // show an error page at the initial request
+    if (options.proxyTimeout) {
+      proxyReq.setTimeout(options.proxyTimeout, function () {
+        proxyReq.destroy();
+      });
+    }
+
+    // Ensure we abort proxy if request is aborted
+    // Need to use different methods due to node changes in 15.0.0.
+
+    // In node < 15.0.0, listen for request abort and destroy the proxy request.
+    req.on('aborted', function () {
+      proxyReq.destroy();
+    });
+    // In node > 15.0.0, listen for the close event on the response.  If it was
+    // destroyed then destroy the proxy request.
+    res.on('close', function () {
+      if (res.destroyed) {
+        proxyReq.destroy();
+      }
+    });
+
+    // handle errors in proxy and incoming request, just like for forward proxy
+    const proxyError = createErrorHandler(proxyReq, options.target);
+    req.on('error', proxyError);
+    proxyReq.on('error', proxyError);
+
+    function createErrorHandler(proxyReq, url) {
+      return function proxyError(err) {
+        if (req.socket.destroyed && err.code === 'ECONNRESET') {
+          server.emit('econnreset', err, req, res, url);
+          proxyReq.destroy();
+          return;
+        }
+
+        if (clb) {
+          clb(err, req, res, url);
+        } else {
+          server.emit('error', err, req, res, url);
+        }
+      };
+    }
+
+    (options.buffer || req).pipe(proxyReq);
+
+    proxyReq.on('response', function (proxyRes) {
+      if (server) {
+        server.emit('proxyRes', proxyRes, req, res);
+      }
+
+      if (!res.headersSent && !options.selfHandleResponse) {
+        for (let i = 0; i < web_o.length; i++) {
+          if (web_o[i](req, res, proxyRes, options)) {
+            break;
+          }
+        }
+      }
+
+      if (!res.finished) {
+        // Allow us to listen when the proxy has completed
+        proxyRes.on('end', function () {
+          if (server) server.emit('end', req, res, proxyRes);
+        });
+        // We pipe to the response unless its expected to be handled by the user
+        if (!options.selfHandleResponse) proxyRes.pipe(res);
+      } else {
+        if (server) server.emit('end', req, res, proxyRes);
+      }
+    });
+  },
+};

package/temp/node-http-proxy/lib/http-proxy/passes/web-outgoing.js

@@ -0,0 +1,163 @@
+const url = require('url'),
+  common = require('../common');
+
+const redirectRegex = /^201|30(1|2|7|8)$/;
+
+/*!
+ * Array of passes.
+ *
+ * A `pass` is just a function that is executed on `req, res, options`
+ * so that you can easily add new checks while still keeping the base
+ * flexible.
+ */
+
+module.exports = {
+  // <--
+
+  /**
+   * If is a HTTP 1.0 request, remove chunk headers
+   *
+   * @param {ClientRequest} req Request object
+   * @param {IncomingMessage} res Response object
+   * @param {proxyResponse} proxyRes Response object from the proxy request
+   *
+   * @api private
+   */
+  removeChunked: function removeChunked(req, res, proxyRes) {
+    if (req.httpVersion === '1.0') {
+      delete proxyRes.headers['transfer-encoding'];
+    }
+  },
+
+  /**
+   * If is a HTTP 1.0 request, set the correct connection header
+   * or if connection header not present, then use `keep-alive`
+   *
+   * @param {ClientRequest} req Request object
+   * @param {IncomingMessage} res Response object
+   * @param {proxyResponse} proxyRes Response object from the proxy request
+   *
+   * @api private
+   */
+  setConnection: function setConnection(req, res, proxyRes) {
+    if (req.httpVersion === '1.0') {
+      proxyRes.headers.connection = req.headers.connection || 'close';
+    } else if (req.httpVersion !== '2.0' && !proxyRes.headers.connection) {
+      proxyRes.headers.connection = req.headers.connection || 'keep-alive';
+    }
+  },
+
+  setRedirectHostRewrite: function setRedirectHostRewrite(
+    req,
+    res,
+    proxyRes,
+    options,
+  ) {
+    if (
+      (options.hostRewrite || options.autoRewrite || options.protocolRewrite) &&
+      proxyRes.headers['location'] &&
+      redirectRegex.test(proxyRes.statusCode)
+    ) {
+      const target = url.parse(options.target);
+      const u = url.parse(proxyRes.headers['location']);
+
+      // make sure the redirected host matches the target host before rewriting
+      if (target.host != u.host) {
+        return;
+      }
+
+      if (options.hostRewrite) {
+        u.host = options.hostRewrite;
+      } else if (options.autoRewrite) {
+        u.host = req.headers['host'];
+      }
+      if (options.protocolRewrite) {
+        u.protocol = options.protocolRewrite;
+      }
+
+      proxyRes.headers['location'] = u.format();
+    }
+  },
+  /**
+   * Copy headers from proxyResponse to response
+   * set each header in response object.
+   *
+   * @param {ClientRequest} req Request object
+   * @param {IncomingMessage} res Response object
+   * @param {proxyResponse} proxyRes Response object from the proxy request
+   * @param {Object} options options.cookieDomainRewrite: Config to rewrite cookie domain
+   *
+   * @api private
+   */
+  writeHeaders: function writeHeaders(req, res, proxyRes, options) {
+    let rewriteCookieDomainConfig = options.cookieDomainRewrite,
+      rewriteCookiePathConfig = options.cookiePathRewrite,
+      rawHeaderKeyMap;
+    const preserveHeaderKeyCase = options.preserveHeaderKeyCase,
+      setHeader = function (key, header) {
+        if (header == undefined) return;
+        if (rewriteCookieDomainConfig && key.toLowerCase() === 'set-cookie') {
+          header = common.rewriteCookieProperty(
+            header,
+            rewriteCookieDomainConfig,
+            'domain',
+          );
+        }
+        if (rewriteCookiePathConfig && key.toLowerCase() === 'set-cookie') {
+          header = common.rewriteCookieProperty(
+            header,
+            rewriteCookiePathConfig,
+            'path',
+          );
+        }
+        res.setHeader(String(key).trim(), header);
+      };
+
+    if (typeof rewriteCookieDomainConfig === 'string') {
+      //also test for ''
+      rewriteCookieDomainConfig = { '*': rewriteCookieDomainConfig };
+    }
+
+    if (typeof rewriteCookiePathConfig === 'string') {
+      //also test for ''
+      rewriteCookiePathConfig = { '*': rewriteCookiePathConfig };
+    }
+
+    // message.rawHeaders is added in: v0.11.6
+    // https://nodejs.org/api/http.html#http_message_rawheaders
+    if (preserveHeaderKeyCase && proxyRes.rawHeaders != undefined) {
+      rawHeaderKeyMap = {};
+      for (let i = 0; i < proxyRes.rawHeaders.length; i += 2) {
+        const key = proxyRes.rawHeaders[i];
+        rawHeaderKeyMap[key.toLowerCase()] = key;
+      }
+    }
+
+    Object.keys(proxyRes.headers).forEach(function (key) {
+      const header = proxyRes.headers[key];
+      if (preserveHeaderKeyCase && rawHeaderKeyMap) {
+        key = rawHeaderKeyMap[key] || key;
+      }
+      setHeader(key, header);
+    });
+  },
+
+  /**
+   * Set the statusCode from the proxyResponse
+   *
+   * @param {ClientRequest} req Request object
+   * @param {IncomingMessage} res Response object
+   * @param {proxyResponse} proxyRes Response object from the proxy request
+   *
+   * @api private
+   */
+  writeStatusCode: function writeStatusCode(req, res, proxyRes) {
+    // From Node.js docs: response.writeHead(statusCode[, statusMessage][, headers])
+    if (proxyRes.statusMessage) {
+      res.statusCode = proxyRes.statusCode;
+      res.statusMessage = proxyRes.statusMessage;
+    } else {
+      res.statusCode = proxyRes.statusCode;
+    }
+  },
+};