cloudcms-server 0.9.270 → 0.9.271

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

@@ -0,0 +1,135 @@
+"use strict";
+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;
+        }
+    },
+};

package/temp/http-proxy/lib/http-proxy/passes/ws-incoming.js

@@ -0,0 +1,141 @@
+"use strict";
+const http = require('http'), https = require('https'), common = require('../common');
+/*!
+ * Array of passes.
+ *
+ * A `pass` is just a function that is executed on `req, socket, options`
+ * so that you can easily add new checks while still keeping the base
+ * flexible.
+ */
+/*
+ * Websockets Passes
+ *
+ */
+module.exports = {
+    /**
+     * WebSocket requests must have the `GET` method and
+     * the `upgrade:websocket` header
+     *
+     * @param {ClientRequest} req Request object
+     * @param {Socket} socket
+     *
+     * @api private
+     */
+    checkMethodAndHeader: function checkMethodAndHeader(req, socket) {
+        if (req.method !== 'GET' || !req.headers.upgrade) {
+            socket.destroy();
+            return true;
+        }
+        if (req.headers.upgrade.toLowerCase() !== 'websocket') {
+            socket.destroy();
+            return true;
+        }
+    },
+    /**
+     * Sets `x-forwarded-*` headers if specified in config.
+     *
+     * @param {ClientRequest} req Request object
+     * @param {Socket} socket
+     * @param {Object} options Config object passed to the proxy
+     *
+     * @api private
+     */
+    XHeaders: function XHeaders(req, socket, options) {
+        if (!options.xfwd)
+            return;
+        const values = {
+            for: req.connection.remoteAddress || req.socket.remoteAddress,
+            port: common.getPort(req),
+            proto: common.hasEncryptedConnection(req) ? 'wss' : 'ws',
+        };
+        ['for', 'port', 'proto'].forEach(function (header) {
+            req.headers['x-forwarded-' + header] =
+                (req.headers['x-forwarded-' + header] || '') +
+                    (req.headers['x-forwarded-' + header] ? ',' : '') +
+                    values[header];
+        });
+    },
+    /**
+     * Does the actual proxying. Make the request and upgrade it
+     * send the Switching Protocols request and pipe the sockets.
+     *
+     * @param {ClientRequest} req Request object
+     * @param {Socket} socket
+     * @param {Object} options Config object passed to the proxy
+     *
+     * @api private
+     */
+    stream: function stream(req, socket, options, head, server, clb) {
+        const createHttpHeader = function (line, headers) {
+            return (Object.keys(headers)
+                .reduce(function (head, key) {
+                const value = headers[key];
+                if (!Array.isArray(value)) {
+                    head.push(key + ': ' + value);
+                    return head;
+                }
+                for (let i = 0; i < value.length; i++) {
+                    head.push(key + ': ' + value[i]);
+                }
+                return head;
+            }, [line])
+                .join('\r\n') + '\r\n\r\n');
+        };
+        common.setupSocket(socket);
+        if (head && head.length)
+            socket.unshift(head);
+        const proxyReq = (common.isSSL.test(options.target.protocol) ? https : http).request(common.setupOutgoing(options.ssl || {}, options, req));
+        // Enable developers to modify the proxyReq before headers are sent
+        if (server) {
+            server.emit('proxyReqWs', proxyReq, req, socket, options, head);
+        }
+        // Error Handler
+        proxyReq.on('error', onOutgoingError);
+        proxyReq.on('response', function (res) {
+            // if upgrade event isn't going to happen, close the socket
+            if (!res.upgrade) {
+                socket.write(createHttpHeader('HTTP/' +
+                    res.httpVersion +
+                    ' ' +
+                    res.statusCode +
+                    ' ' +
+                    res.statusMessage, res.headers));
+                res.pipe(socket);
+            }
+        });
+        proxyReq.on('upgrade', function (proxyRes, proxySocket, proxyHead) {
+            proxySocket.on('error', onOutgoingError);
+            // Allow us to listen when the websocket has completed
+            proxySocket.on('end', function () {
+                server.emit('close', proxyRes, proxySocket, proxyHead);
+            });
+            // The pipe below will end proxySocket if socket closes cleanly, but not
+            // if it errors (eg, vanishes from the net and starts returning
+            // EHOSTUNREACH). We need to do that explicitly.
+            socket.on('error', function () {
+                proxySocket.end();
+            });
+            common.setupSocket(proxySocket);
+            if (proxyHead && proxyHead.length)
+                proxySocket.unshift(proxyHead);
+            //
+            // Remark: Handle writing the headers to the socket when switching protocols
+            // Also handles when a header is an array
+            //
+            socket.write(createHttpHeader('HTTP/1.1 101 Switching Protocols', proxyRes.headers));
+            proxySocket.pipe(socket).pipe(proxySocket);
+            server.emit('open', proxySocket);
+            server.emit('proxySocket', proxySocket); //DEPRECATED.
+        });
+        return proxyReq.end(); // XXX: CHECK IF THIS IS THIS CORRECT
+        function onOutgoingError(err) {
+            if (clb) {
+                clb(err, req, socket);
+            }
+            else {
+                server.emit('error', err, req, socket);
+            }
+            socket.end();
+        }
+    },
+};

package/temp/http-proxy/lib/index.js

@@ -0,0 +1,13 @@
+"use strict";
+/*!
+ * Caron dimonio, con occhi di bragia
+ * loro accennando, tutte le raccoglie;
+ * batte col remo qualunque s’adagia
+ *
+ * Charon the demon, with the eyes of glede,
+ * Beckoning to them, collects them all together,
+ * Beats with his oar whoever lags behind
+ *
+ *          Dante - The Divine Comedy (Canto III)
+ */
+module.exports = './http-proxy';

package/temp/http-proxy/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "http-proxy",
+  "version": "1.18.1",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/http-party/node-http-proxy.git"
+  },
+  "description": "HTTP proxying for the masses",
+  "author": "Charlie Robbins <charlie.robbins@gmail.com>",
+  "maintainers": [
+    "jcrugzz <jcrugzz@gmail.com>"
+  ],
+  "main": "index.js",
+  "dependencies": {
+    "eventemitter3": "^4.0.0",
+    "requires-port": "^1.0.0",
+    "follow-redirects": "^1.0.0"
+  },
+  "devDependencies": {
+    "async": "^3.0.0",
+    "auto-changelog": "^1.15.0",
+    "concat-stream": "^2.0.0",
+    "expect.js": "~0.3.1",
+    "mocha": "^3.5.3",
+    "nyc": "^14.0.0",
+    "semver": "^5.0.3",
+    "socket.io": "^2.1.0",
+    "socket.io-client": "^2.1.0",
+    "sse": "0.0.8",
+    "ws": "^3.0.0"
+  },
+  "scripts": {
+    "mocha": "mocha test/*-test.js",
+    "test": "nyc --reporter=text --reporter=lcov npm run mocha",
+    "version": "auto-changelog -p && git add CHANGELOG.md"
+  },
+  "engines": {
+    "node": ">=8.0.0"
+  },
+  "license": "MIT"
+}

package/temp/http-proxy/renovate.json

@@ -0,0 +1,19 @@
+{
+  "platform": "github",
+  "autodiscover": false,
+  "requireConfig": true,
+  "ignoreNpmrcFile": true,
+  "rangeStrategy": "replace",
+  "packageRules": [
+    {
+      "packagePatterns": [
+        "*"
+      ],
+      "minor": {
+        "groupName": "all non-major dependencies",
+        "groupSlug": "all-minor-patch"
+      }
+    }
+  ],
+  "commitMessagePrefix": "[dist]"
+}

package/temp/node-http-proxy/.eslintignore

@@ -0,0 +1,3 @@
+.eslintrc.js
+node_modules
+vitest.config.ts

package/temp/node-http-proxy/.eslintrc.js

@@ -0,0 +1,21 @@
+module.exports = {
+  root: true,
+  parser: '@typescript-eslint/parser',
+  parserOptions: {
+    project: './tsconfig.json',
+  },
+  plugins: ['@typescript-eslint'],
+  extends: ['eslint:recommended', 'plugin:@typescript-eslint/recommended'],
+  env: {
+    node: true,
+    es2016: true,
+    // Not using jest, but the test globals are jest-like so this works.
+    jest: true,
+  },
+  rules: {
+    '@typescript-eslint/ban-ts-comment': ['off'],
+    '@typescript-eslint/no-empty-function': ['off'],
+    'no-var': ['error'],
+    'prefer-const': ['error'],
+  },
+};

package/temp/node-http-proxy/.github/workflows/ci.yml

@@ -0,0 +1,30 @@
+# This workflow will do a clean installation of node dependencies, cache/restore them, build the source code and run tests across different versions of node
+# For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
+
+name: CI
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [14.x, 16.x, 18.x]
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v3
+      with:
+        node-version: ${{ matrix.node-version }}
+        cache: 'npm'
+    - run: npm ci
+    - run: npm run build
+    - run: npm run test

package/temp/node-http-proxy/.prettierrc

@@ -0,0 +1,7 @@
+{
+  "arrowParens": "always",
+  "quoteProps": "as-needed",
+  "semi": true,
+  "singleQuote": true,
+  "trailingComma": "all"
+}

package/temp/node-http-proxy/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at <https://github.com/http-party/node-http-proxy>. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

package/temp/node-http-proxy/LICENSE

@@ -0,0 +1,23 @@
+
+  node-http-proxy
+
+  Copyright (c) 2010-2016 Charlie Robbins, Jarrett Cruger & the Contributors.
+
+  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.