Replace old xhr2-cookies with local xhr2-cookies-patched deps for 1.x, fix User-Agent header problem

CHANGELOG.md

@@ -523,4 +523,7 @@ Released with 1.0.0-beta.37 code base.
 
 ## [Unreleased]
 
-## [1.8.0]
+### Fixed
+- Replaced xhr2-cookies dependency from web3-providers-http module to enable using custom `User-Agent` headers (#4808)
+
+## [1.8.0]

packages/web3-providers-http/local_modules/xhr2-cookies-patched/.gitignore

@@ -0,0 +1,8 @@
+node_modules
+yarn-error.log
+.idea
+!wallaby.js
+*.js
+*.js.map
+test/*.js
+test/*.js.map

packages/web3-providers-http/local_modules/xhr2-cookies-patched/.npmignore

@@ -0,0 +1,4 @@
+*
+.idea
+!dist/*
+!package.json

packages/web3-providers-http/local_modules/xhr2-cookies-patched/README.md

@@ -0,0 +1,30 @@
+# XMLHttpRequest polyfill for node.js
+
+Based on [https://github.com/souldreamer/xhr2-cookies](https://github.com/souldreamer/xhr2-cookies)
+
+* Adds support for cookies
+* Adds in-project TypeScript type definitions
+* Switched to TypeScript
+
+### Cookies
+
+* saved in `XMLHttpRequest.cookieJar`
+* saved between redirects
+* saved between requests
+* can be cleared by doing:
+```typescript
+import * as Cookie from 'cookiejar';
+XMLHttpRequest.cookieJar = Cookie.CookieJar();
+```
+
+### Aims
+
+* Provide full XMLHttpRequest features to Angular Universal HttpClient &
+`node-angular-http-client`
+
+### Changelog
+
+#### `1.1.0`
+* added saving of cookies between requests, not just redirects
+* bug fixes
+* most tests from `xhr2` ported over and passing

packages/web3-providers-http/local_modules/xhr2-cookies-patched/dist/errors.d.ts

@@ -0,0 +1,8 @@
+export declare class SecurityError extends Error {
+}
+export declare class InvalidStateError extends Error {
+}
+export declare class NetworkError extends Error {
+}
+export declare class SyntaxError extends Error {
+}

packages/web3-providers-http/local_modules/xhr2-cookies-patched/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './xml-http-request';
+export { XMLHttpRequestEventTarget } from './xml-http-request-event-target';

packages/web3-providers-http/local_modules/xhr2-cookies-patched/dist/progress-event.d.ts

@@ -0,0 +1,11 @@
+import { XMLHttpRequestEventTarget } from './xml-http-request-event-target';
+export declare class ProgressEvent {
+ type: string;
+ bubbles: boolean;
+ cancelable: boolean;
+ target: XMLHttpRequestEventTarget;
+ loaded: number;
+ lengthComputable: boolean;
+ total: number;
+ constructor(type: string);
+}

packages/web3-providers-http/local_modules/xhr2-cookies-patched/dist/xml-http-request-event-target.d.ts

@@ -0,0 +1,19 @@
+import { ProgressEvent } from './progress-event';
+export declare type ProgressEventListener = (event: ProgressEvent) => void;
+export declare type ProgressEventListenerObject = {
+ handleEvent(event: ProgressEvent): void;
+};
+export declare type ProgressEventListenerOrEventListenerObject = ProgressEventListener | ProgressEventListenerObject;
+export declare class XMLHttpRequestEventTarget {
+ onloadstart: ProgressEventListener | null;
+ onprogress: ProgressEventListener | null;
+ onabort: ProgressEventListener | null;
+ onerror: ProgressEventListener | null;
+ onload: ProgressEventListener | null;
+ ontimeout: ProgressEventListener | null;
+ onloadend: ProgressEventListener | null;
+ private listeners;
+ addEventListener(eventType: string, listener?: ProgressEventListenerOrEventListenerObject): void;
+ removeEventListener(eventType: string, listener?: ProgressEventListenerOrEventListenerObject): void;
+ dispatchEvent(event: ProgressEvent): boolean;
+}

packages/web3-providers-http/local_modules/xhr2-cookies-patched/dist/xml-http-request-upload.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+import { XMLHttpRequestEventTarget } from './xml-http-request-event-target';
+import { ClientRequest } from 'http';
+export declare class XMLHttpRequestUpload extends XMLHttpRequestEventTarget {
+ private _contentType;
+ private _body;
+ constructor();
+ _reset(): void;
+ _setData(data?: string | Buffer | ArrayBuffer | ArrayBufferView): void;
+ _finalizeHeaders(headers: object, loweredHeaders: object): void;
+ _startUpload(request: ClientRequest): void;
+}

packages/web3-providers-http/local_modules/xhr2-cookies-patched/dist/xml-http-request.d.ts

@@ -0,0 +1,102 @@
+/// <reference types="node" />
+import { ProgressEvent } from './progress-event';
+import { InvalidStateError, NetworkError, SecurityError, SyntaxError } from './errors';
+import { ProgressEventListener, XMLHttpRequestEventTarget } from './xml-http-request-event-target';
+import { XMLHttpRequestUpload } from './xml-http-request-upload';
+import { Url } from 'url';
+import { Agent as HttpAgent } from 'http';
+import { Agent as HttpsAgent } from 'https';
+export interface XMLHttpRequestOptions {
+ anon?: boolean;
+}
+export interface XHRUrl extends Url {
+ method?: string;
+}
+export declare class XMLHttpRequest extends XMLHttpRequestEventTarget {
+ static ProgressEvent: typeof ProgressEvent;
+ static InvalidStateError: typeof InvalidStateError;
+ static NetworkError: typeof NetworkError;
+ static SecurityError: typeof SecurityError;
+ static SyntaxError: typeof SyntaxError;
+ static XMLHttpRequestUpload: typeof XMLHttpRequestUpload;
+ static UNSENT: number;
+ static OPENED: number;
+ static HEADERS_RECEIVED: number;
+ static LOADING: number;
+ static DONE: number;
+ static cookieJar: any;
+ UNSENT: number;
+ OPENED: number;
+ HEADERS_RECEIVED: number;
+ LOADING: number;
+ DONE: number;
+ onreadystatechange: ProgressEventListener | null;
+ readyState: number;
+ response: string | ArrayBuffer | Buffer | object | null;
+ responseText: string;
+ responseType: string;
+ status: number;
+ statusText: string;
+ timeout: number;
+ upload: XMLHttpRequestUpload;
+ responseUrl: string;
+ withCredentials: boolean;
+ nodejsHttpAgent: HttpsAgent;
+ nodejsHttpsAgent: HttpsAgent;
+ nodejsBaseUrl: string | null;
+ private _anonymous;
+ private _method;
+ private _url;
+ private _sync;
+ private _headers;
+ private _loweredHeaders;
+ private _mimeOverride;
+ private _request;
+ private _response;
+ private _responseParts;
+ private _responseHeaders;
+ private _aborting;
+ private _error;
+ private _loadedBytes;
+ private _totalBytes;
+ private _lengthComputable;
+ private _restrictedMethods;
+ private _restrictedHeaders;
+ private _privateHeaders;
+ private _userAgent;
+ constructor(options?: XMLHttpRequestOptions);
+ open(method: string, url: string, async?: boolean, user?: string, password?: string): void;
+ setRequestHeader(name: string, value: any): void;
+ send(data?: string | Buffer | ArrayBuffer | ArrayBufferView): void;
+ abort(): void;
+ getResponseHeader(name: string): string;
+ getAllResponseHeaders(): string;
+ overrideMimeType(mimeType: string): void;
+ nodejsSet(options: {
+ httpAgent?: HttpAgent;
+ httpsAgent?: HttpsAgent;
+ baseUrl?: string;
+ }): void;
+ static nodejsSet(options: {
+ httpAgent?: HttpAgent;
+ httpsAgent?: HttpsAgent;
+ baseUrl?: string;
+ }): void;
+ private _setReadyState(readyState);
+ private _sendFile(data);
+ private _sendHttp(data?);
+ private _sendHxxpRequest();
+ private _finalizeHeaders();
+ private _onHttpResponse(request, response);
+ private _onHttpResponseData(response, data);
+ private _onHttpResponseEnd(response);
+ private _onHttpResponseClose(response);
+ private _onHttpTimeout(request);
+ private _onHttpRequestError(request, error);
+ private _dispatchProgress(eventType);
+ private _setError();
+ private _parseUrl(urlString, user?, password?);
+ private _parseResponseHeaders(response);
+ private _parseResponse();
+ private _parseResponseEncoding();
+}

packages/web3-providers-http/local_modules/xhr2-cookies-patched/errors.ts

@@ -0,0 +1,4 @@
+export class SecurityError extends Error {}
+export class InvalidStateError extends Error {}
+export class NetworkError extends Error {}
+export class SyntaxError extends Error {}

packages/web3-providers-http/local_modules/xhr2-cookies-patched/index.ts

@@ -0,0 +1,2 @@
+export * from './xml-http-request';
+export { XMLHttpRequestEventTarget } from './xml-http-request-event-target';

packages/web3-providers-http/local_modules/xhr2-cookies-patched/package.json

@@ -0,0 +1,48 @@
+{
+ "name": "xhr2-cookies-patched",
+ "version": "1.1.0",
+ "author": "Ayanami <ayanami0330@protonmail.com>",
+ "license": "MIT",
+ "description": "XMLHttpRequest polyfill for node.js",
+ "repository": "git://github.com/0xAyanami/xhr2-cookies.git",
+ "keywords": [
+ "XMLHttpRequest",
+ "cookies",
+ "xhr2"
+ ],
+ "main": "dist/index.js",
+ "types": "dist/index.d.ts",
+ "dependencies": {
+ "cookiejar": "^2.1.3"
+ },
+ "devDependencies": {
+ "@types/body-parser": "^1.16.8",
+ "@types/cookie-parser": "^1.4.1",
+ "@types/express": "^4.0.39",
+ "@types/morgan": "^1.7.35",
+ "@types/node": "^6",
+ "ava": "^0.23.0",
+ "ava-ts": "^0.23.0",
+ "body-parser": "^1.18.2",
+ "cookie-parser": "^1.4.3",
+ "express": "^4.16.2",
+ "morgan": "^1.9.0",
+ "ts-loader": "^2.3.4",
+ "ts-node": "^3.3.0",
+ "typescript": "^2.5.2",
+ "webpack": "^3.5.5"
+ },
+ "scripts": {
+ "prepare": "tsc",
+ "test": "tsc -p ./test && ava-ts -v"
+ },
+ "ava": {
+ "files": [
+ "test/*.spec.ts"
+ ],
+ "source": [
+ "*.ts",
+ "!dist/**/*"
+ ]
+ }
+}

packages/web3-providers-http/local_modules/xhr2-cookies-patched/progress-event.ts

@@ -0,0 +1,12 @@
+import { XMLHttpRequestEventTarget } from './xml-http-request-event-target';
+
+export class ProgressEvent {
+ bubbles = false;
+ cancelable = false;
+ target: XMLHttpRequestEventTarget;
+ loaded = 0;
+ lengthComputable = false;
+ total = 0;
+
+ constructor (public type: string) {}
+}

packages/web3-providers-http/local_modules/xhr2-cookies-patched/test/cookies.spec.ts

@@ -0,0 +1,59 @@
+import * as ava from 'ava';
+import { XMLHttpRequest } from '../xml-http-request';
+import { HttpServer } from './helpers/server';
+import * as Cookie from 'cookiejar';
+
+function contextualize<T>(getContext: () => T): ava.RegisterContextual<T> {
+ ava.test.beforeEach(t => {
+ Object.assign(t.context, getContext());
+ });
+ return ava.test;
+}
+
+const test = contextualize(() => ({
+ xhr: new XMLHttpRequest()
+}));
+
+test.before(async () => {
+ await HttpServer.serverStarted;
+});
+
+test.beforeEach(t => {
+ t.context.xhr = new XMLHttpRequest();
+ XMLHttpRequest.cookieJar = Cookie.CookieJar();
+});
+
+test('XMLHttpRequest sets cookies and passes them on on redirect', async t => {
+ const xhr = t.context.xhr;
+ t.plan(1);
+ await new Promise(resolve => {
+ xhr.open('GET', `http://localhost:${HttpServer.port}/_/redirect-cookie/test/works`);
+ xhr.withCredentials = true;
+ xhr.onload = () => {
+ t.is(xhr.responseText, 'works');
+ resolve();
+ };
+ xhr.send();
+ });
+});
+
+test('XMLHttpRequest sets cookies and uses them for subsequent calls', async t => {
+ let xhr = t.context.xhr;
+ t.plan(1);
+ await new Promise(resolve => {
+ xhr.open('GET', `http://localhost:${HttpServer.port}/_/set-cookie/second-test/works`);
+ xhr.withCredentials = true;
+ xhr.onload = resolve;
+ xhr.send();
+ });
+ xhr = new XMLHttpRequest();
+ await new Promise(resolve => {
+ xhr.open('GET', `http://localhost:${HttpServer.port}/_/print-cookie/second-test`);
+ xhr.withCredentials = true;
+ xhr.onload = () => {
+ t.is(xhr.responseText, 'works');
+ resolve();
+ };
+ xhr.send();
+ });
+});