perimeterx-js-core 0.1.0

package/lib/first_party/DefaultFirstParty.d.ts

@@ -0,0 +1,22 @@
+import { IConfiguration } from '../config';
+import { IContext } from '../context/IContext';
+import { IHttpClient, IHttpResponse } from '../http';
+import { IFirstParty } from './IFirstParty';
+export declare class DefaultFirstParty implements IFirstParty {
+    private readonly config;
+    private readonly httpClient;
+    constructor(config: IConfiguration, httpClient: IHttpClient);
+    handleFirstPartyRequest(context: IContext): Promise<IHttpResponse>;
+    private proxySensorScriptRequest;
+    private proxyXhrRequest;
+    private static getDefaultXhrResponse;
+    private proxyCaptchaScriptRequest;
+    private forwardRequest;
+    private prepareFirstPartyHeaders;
+    private setHostHeader;
+    private setXffHeader;
+    private addFirstPartyHeaders;
+    private getThirdPartySensorScriptUrl;
+    private getThirdPartyCaptchaScriptUrl;
+    private getThirdPartyXhrUrl;
+}

package/lib/first_party/DefaultFirstParty.js

@@ -0,0 +1,215 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultFirstParty = void 0;
+var utils_1 = require("../utils");
+var http_1 = require("../http");
+var utils_2 = require("./utils");
+var constants_1 = require("./constants");
+var DefaultFirstParty = /** @class */ (function () {
+    function DefaultFirstParty(config, httpClient) {
+        this.config = config;
+        this.httpClient = httpClient;
+    }
+    DefaultFirstParty.prototype.handleFirstPartyRequest = function (context) {
+        return __awaiter(this, void 0, void 0, function () {
+            var pathname, xhrPrefix, captchaPrefix;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        pathname = context.requestData.url.pathname;
+                        if (!(0, utils_2.getFirstPartySensorScriptPaths)(this.config).includes(pathname)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.proxySensorScriptRequest(context)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                    case 2:
+                        xhrPrefix = (0, utils_2.getFirstPartyXhrPathPrefixes)(this.config).find(function (prefix) { return pathname.startsWith(prefix); });
+                        if (!xhrPrefix) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.proxyXhrRequest(context, xhrPrefix)];
+                    case 3: return [2 /*return*/, _a.sent()];
+                    case 4:
+                        captchaPrefix = (0, utils_2.getFirstPartyCaptchaScriptPathPrefixes)(this.config).find(function (prefix) {
+                            return pathname.startsWith(prefix);
+                        });
+                        if (!captchaPrefix) return [3 /*break*/, 6];
+                        return [4 /*yield*/, this.proxyCaptchaScriptRequest(context, captchaPrefix)];
+                    case 5: return [2 /*return*/, _a.sent()];
+                    case 6: return [2 /*return*/, null];
+                }
+            });
+        });
+    };
+    DefaultFirstParty.prototype.proxySensorScriptRequest = function (context) {
+        return __awaiter(this, void 0, void 0, function () {
+            var url, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.config.firstPartyEnabled) {
+                            return [2 /*return*/, new http_1.DefaultHttpResponse(constants_1.DEFAULT_CLIENT_RESPONSE.content, constants_1.DEFAULT_CLIENT_RESPONSE.options)];
+                        }
+                        url = this.getThirdPartySensorScriptUrl();
+                        return [4 /*yield*/, this.forwardRequest(url, context)];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, response
+                                ? response
+                                : new http_1.DefaultHttpResponse(constants_1.DEFAULT_CLIENT_RESPONSE.content, constants_1.DEFAULT_CLIENT_RESPONSE.options)];
+                }
+            });
+        });
+    };
+    DefaultFirstParty.prototype.proxyXhrRequest = function (context, prefix) {
+        return __awaiter(this, void 0, void 0, function () {
+            var url, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.config.firstPartyEnabled) {
+                            return [2 /*return*/, DefaultFirstParty.getDefaultXhrResponse(context.requestData.url.pathname)];
+                        }
+                        url = this.getThirdPartyXhrUrl(context, prefix);
+                        return [4 /*yield*/, this.forwardRequest(url, context)];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, (response === null || response === void 0 ? void 0 : response.status) < 400
+                                ? response
+                                : DefaultFirstParty.getDefaultXhrResponse(context.requestData.url.pathname)];
+                }
+            });
+        });
+    };
+    DefaultFirstParty.getDefaultXhrResponse = function (path) {
+        var _a = path.endsWith('.gif') ? constants_1.DEFAULT_GIF_RESPONSE : constants_1.DEFAULT_XHR_RESPONSE, content = _a.content, options = _a.options;
+        return new http_1.DefaultHttpResponse(content, options);
+    };
+    DefaultFirstParty.prototype.proxyCaptchaScriptRequest = function (context, prefix) {
+        return __awaiter(this, void 0, void 0, function () {
+            var url, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.config.firstPartyEnabled) {
+                            return [2 /*return*/, new http_1.DefaultHttpResponse(constants_1.DEFAULT_CLIENT_RESPONSE.content, constants_1.DEFAULT_CLIENT_RESPONSE.options)];
+                        }
+                        url = this.getThirdPartyCaptchaScriptUrl(context, prefix);
+                        return [4 /*yield*/, this.forwardRequest(url, context)];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, response
+                                ? response
+                                : new http_1.DefaultHttpResponse(constants_1.DEFAULT_CLIENT_RESPONSE.content, constants_1.DEFAULT_CLIENT_RESPONSE.options)];
+                }
+            });
+        });
+    };
+    DefaultFirstParty.prototype.forwardRequest = function (url, _a) {
+        var requestData = _a.requestData, vid = _a.vid;
+        return __awaiter(this, void 0, void 0, function () {
+            var firstPartyReq, e_1;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 2, , 3]);
+                        firstPartyReq = requestData.request;
+                        firstPartyReq.url = url;
+                        firstPartyReq.headers = this.prepareFirstPartyHeaders(url, requestData, vid);
+                        this.config.logger.debug('forwarding to ' + url);
+                        return [4 /*yield*/, this.httpClient.send(firstPartyReq)];
+                    case 1: return [2 /*return*/, _b.sent()];
+                    case 2:
+                        e_1 = _b.sent();
+                        this.config.logger.debug("failed sending first party request to ".concat(url));
+                        return [2 /*return*/, null];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    DefaultFirstParty.prototype.prepareFirstPartyHeaders = function (url, requestData, vid) {
+        var headers = requestData.headers.copy();
+        try {
+            headers = (0, utils_1.removeSensitiveHeaders)(headers, this.config.sensitiveHeaders);
+            this.setHostHeader(headers, url);
+            this.setXffHeader(headers, requestData.ip);
+            this.addFirstPartyHeaders(headers, requestData.ip);
+            if (vid) {
+                headers.append(http_1.COOKIE_HEADER_NAME, "pxvid=".concat(vid));
+            }
+        }
+        catch (e) {
+            this.config.logger.error("Caught error preparing first party headers: ".concat(e));
+        }
+        return headers;
+    };
+    DefaultFirstParty.prototype.setHostHeader = function (headers, url) {
+        var host = new URL(url).host;
+        headers.set(http_1.HOST_HEADER_NAME, host);
+    };
+    DefaultFirstParty.prototype.setXffHeader = function (headers, ip) {
+        var _a;
+        var xffValue = (_a = headers.get(http_1.X_FORWARDED_FOR_HEADER_NAME)) === null || _a === void 0 ? void 0 : _a[0];
+        if (xffValue) {
+            xffValue += ", ".concat(ip);
+        }
+        else {
+            xffValue = ip;
+        }
+        headers.set(http_1.X_FORWARDED_FOR_HEADER_NAME, xffValue);
+    };
+    DefaultFirstParty.prototype.addFirstPartyHeaders = function (headers, ip) {
+        headers.set(constants_1.FIRST_PARTY_HEADER_NAME, constants_1.FIRST_PARTY_HEADER_VALUE);
+        headers.set(constants_1.X_PX_ENFORCER_TRUE_IP_HEADER_NAME, ip);
+    };
+    DefaultFirstParty.prototype.getThirdPartySensorScriptUrl = function () {
+        return "".concat(this.config.backendClientUrl, "/").concat(this.config.appId, "/main.min.js");
+    };
+    DefaultFirstParty.prototype.getThirdPartyCaptchaScriptUrl = function (context, prefix) {
+        var originalUrl = context.requestData.url;
+        var _a = this.config, appId = _a.appId, backendCaptchaUrl = _a.backendCaptchaUrl;
+        var regExString = "".concat(originalUrl.origin).concat(prefix);
+        var regEx = new RegExp(regExString, 'ig');
+        return "".concat(backendCaptchaUrl, "/").concat(appId).concat(originalUrl.href.replace(regEx, ''));
+    };
+    DefaultFirstParty.prototype.getThirdPartyXhrUrl = function (context, prefix) {
+        var originalUrl = context.requestData.url;
+        var backendCollectorUrl = this.config.backendCollectorUrl;
+        return "".concat(backendCollectorUrl).concat(originalUrl.pathname.replace(prefix, '')).concat(originalUrl.search);
+    };
+    return DefaultFirstParty;
+}());
+exports.DefaultFirstParty = DefaultFirstParty;

package/lib/first_party/IFirstParty.d.ts

@@ -0,0 +1,9 @@
+import { IContext } from '../context';
+import { IHttpResponse } from '../http';
+export interface IFirstParty {
+    /**
+     * @param context - The request context
+     * @returns Promise<IHttpResponse<UnreadBodyType>> - If the request is not a first party request, it will return null.
+     */
+    handleFirstPartyRequest(context: IContext): Promise<IHttpResponse>;
+}

package/lib/first_party/IFirstParty.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/first_party/constants.d.ts

@@ -0,0 +1,32 @@
+import { ContentType } from '../http';
+export declare const EMPTY_GIF: number[];
+export declare const X_PX_ENFORCER_TRUE_IP_HEADER_NAME = "x-px-enforcer-true-ip";
+export declare const FIRST_PARTY_HEADER_NAME = "x-px-first-party";
+export declare const FIRST_PARTY_HEADER_VALUE = "1";
+export declare const DEFAULT_CLIENT_RESPONSE: {
+    content: string;
+    options: {
+        status: number;
+        headers: {
+            "content-type": ContentType[];
+        };
+    };
+};
+export declare const DEFAULT_XHR_RESPONSE: {
+    content: string;
+    options: {
+        status: number;
+        headers: {
+            "content-type": ContentType[];
+        };
+    };
+};
+export declare const DEFAULT_GIF_RESPONSE: {
+    content: string;
+    options: {
+        status: number;
+        headers: {
+            "content-type": ContentType[];
+        };
+    };
+};

package/lib/first_party/constants.js

@@ -0,0 +1,39 @@
+"use strict";
+var _a, _b, _c;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_GIF_RESPONSE = exports.DEFAULT_XHR_RESPONSE = exports.DEFAULT_CLIENT_RESPONSE = exports.FIRST_PARTY_HEADER_VALUE = exports.FIRST_PARTY_HEADER_NAME = exports.X_PX_ENFORCER_TRUE_IP_HEADER_NAME = exports.EMPTY_GIF = void 0;
+var http_1 = require("../http");
+exports.EMPTY_GIF = [
+    0x47, 0x49, 0x46, 0x38, 0x39, 0x61, 0x01, 0x00, 0x01, 0x00, 0x80, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,
+    0x2c, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x02, 0x02, 0x44, 0x01, 0x00, 0x3b,
+];
+exports.X_PX_ENFORCER_TRUE_IP_HEADER_NAME = 'x-px-enforcer-true-ip';
+exports.FIRST_PARTY_HEADER_NAME = 'x-px-first-party';
+exports.FIRST_PARTY_HEADER_VALUE = '1';
+exports.DEFAULT_CLIENT_RESPONSE = {
+    content: '',
+    options: {
+        status: 200,
+        headers: (_a = {},
+            _a[http_1.CONTENT_TYPE_HEADER_NAME] = [http_1.ContentType.APPLICATION_JAVASCRIPT],
+            _a),
+    },
+};
+exports.DEFAULT_XHR_RESPONSE = {
+    content: '{}',
+    options: {
+        status: 200,
+        headers: (_b = {},
+            _b[http_1.CONTENT_TYPE_HEADER_NAME] = [http_1.ContentType.APPLICATION_JAVASCRIPT],
+            _b),
+    },
+};
+exports.DEFAULT_GIF_RESPONSE = {
+    content: 'GIF89a\x01\x00\x01\x00\x80\x00\x00ÿÿÿ\x00\x00\x00,\x00\x00\x00\x00\x01\x00\x01\x00\x00\x02\x02D\x01\x00;',
+    options: {
+        status: 200,
+        headers: (_c = {},
+            _c[http_1.CONTENT_TYPE_HEADER_NAME] = [http_1.ContentType.IMAGE_GIF],
+            _c),
+    },
+};

package/lib/first_party/index.d.ts

@@ -0,0 +1,4 @@
+export { IFirstParty } from './IFirstParty';
+export { DefaultFirstParty } from './DefaultFirstParty';
+export * from './utils';
+export * from './constants';

package/lib/first_party/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultFirstParty = void 0;
+var DefaultFirstParty_1 = require("./DefaultFirstParty");
+Object.defineProperty(exports, "DefaultFirstParty", { enumerable: true, get: function () { return DefaultFirstParty_1.DefaultFirstParty; } });
+__exportStar(require("./utils"), exports);
+__exportStar(require("./constants"), exports);

package/lib/first_party/utils.d.ts

@@ -0,0 +1,8 @@
+import { IConfiguration } from '../config';
+export declare const getDefaultFirstPartyPrefix: (appId: string) => string;
+export declare const getFirstPartySensorScriptPaths: (config: IConfiguration) => string[];
+export declare const getFirstPartyCaptchaScriptPathPrefixes: (config: IConfiguration) => string[];
+export declare const getFirstPartyXhrPathPrefixes: (config: IConfiguration) => string[];
+export declare const getFirstPartySensorScriptPath: (prefix: string) => string;
+export declare const getFirstPartyCaptchaScriptPathPrefix: (prefix: string) => string;
+export declare const getFirstPartyXhrPathPrefix: (prefix: string) => string;

package/lib/first_party/utils.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFirstPartyXhrPathPrefix = exports.getFirstPartyCaptchaScriptPathPrefix = exports.getFirstPartySensorScriptPath = exports.getFirstPartyXhrPathPrefixes = exports.getFirstPartyCaptchaScriptPathPrefixes = exports.getFirstPartySensorScriptPaths = exports.getDefaultFirstPartyPrefix = void 0;
+var getDefaultFirstPartyPrefix = function (appId) { return appId.substring(2); };
+exports.getDefaultFirstPartyPrefix = getDefaultFirstPartyPrefix;
+var getFirstPartyPaths = function (config, callback) {
+    var allPrefixes = [config.firstPartyPrefix, (0, exports.getDefaultFirstPartyPrefix)(config.appId)];
+    return Array.from(new Set(allPrefixes)).map(callback);
+};
+var getFirstPartySensorScriptPaths = function (config) {
+    return getFirstPartyPaths(config, exports.getFirstPartySensorScriptPath);
+};
+exports.getFirstPartySensorScriptPaths = getFirstPartySensorScriptPaths;
+var getFirstPartyCaptchaScriptPathPrefixes = function (config) {
+    return getFirstPartyPaths(config, exports.getFirstPartyCaptchaScriptPathPrefix);
+};
+exports.getFirstPartyCaptchaScriptPathPrefixes = getFirstPartyCaptchaScriptPathPrefixes;
+var getFirstPartyXhrPathPrefixes = function (config) {
+    return getFirstPartyPaths(config, exports.getFirstPartyXhrPathPrefix);
+};
+exports.getFirstPartyXhrPathPrefixes = getFirstPartyXhrPathPrefixes;
+var getFirstPartySensorScriptPath = function (prefix) { return "/".concat(prefix, "/init.js"); };
+exports.getFirstPartySensorScriptPath = getFirstPartySensorScriptPath;
+var getFirstPartyCaptchaScriptPathPrefix = function (prefix) { return "/".concat(prefix, "/captcha"); };
+exports.getFirstPartyCaptchaScriptPathPrefix = getFirstPartyCaptchaScriptPathPrefix;
+var getFirstPartyXhrPathPrefix = function (prefix) { return "/".concat(prefix, "/xhr"); };
+exports.getFirstPartyXhrPathPrefix = getFirstPartyXhrPathPrefix;

package/lib/http/IHttpClient.d.ts

@@ -0,0 +1,10 @@
+import { IHttpRequest } from './request/IHttpRequest';
+import { IHttpResponse } from './response/IHttpResponse';
+export interface IHttpClient<UnreadBodyType = unknown> {
+    /**
+     * A function that sends the provided IHttpRequest and returns a Promise resolving to an IHttpResponse.
+     * @param request - The request to be sent by the client.
+     * @returns Promise<IHttpResponse> - A Promise resolving to the response the client received.
+     */
+    send(request: IHttpRequest<UnreadBodyType>): Promise<IHttpResponse<UnreadBodyType>>;
+}

package/lib/http/IHttpClient.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/http/body_reader/IBodyReader.d.ts

@@ -0,0 +1,5 @@
+import { ContentType, HttpBody } from '../utils';
+export interface IBodyReader<UnreadBodyType> {
+    readonly body: UnreadBodyType | string;
+    readBody(contentType: ContentType): Promise<HttpBody>;
+}

package/lib/http/body_reader/IBodyReader.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/http/body_reader/StringBodyReader.d.ts

@@ -0,0 +1,8 @@
+import { ContentType, HttpBody } from '../utils';
+import { IBodyReader } from './IBodyReader';
+export declare class StringBodyReader implements IBodyReader<string> {
+    readonly body: string;
+    constructor(rawBody: string);
+    readBody(contentType: ContentType): Promise<HttpBody>;
+    private convertFormUrlEncodedStringToObject;
+}

package/lib/http/body_reader/StringBodyReader.js

@@ -0,0 +1,70 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringBodyReader = void 0;
+var StringBodyReader = /** @class */ (function () {
+    function StringBodyReader(rawBody) {
+        this.body = rawBody;
+    }
+    StringBodyReader.prototype.readBody = function (contentType) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (!contentType) {
+                    return [2 /*return*/, this.body];
+                }
+                if (contentType.includes('json')) {
+                    return [2 /*return*/, JSON.parse(this.body)];
+                }
+                else if (contentType.includes('form-urlencoded')) {
+                    return [2 /*return*/, this.convertFormUrlEncodedStringToObject(this.body)];
+                }
+                return [2 /*return*/, this.body];
+            });
+        });
+    };
+    StringBodyReader.prototype.convertFormUrlEncodedStringToObject = function (formUrlEncodedString) {
+        var object = {};
+        var params = new URLSearchParams(formUrlEncodedString);
+        params.forEach(function (value, key) {
+            object[key] = value;
+        });
+        return object;
+    };
+    return StringBodyReader;
+}());
+exports.StringBodyReader = StringBodyReader;

package/lib/http/index.d.ts

@@ -0,0 +1,10 @@
+export { IHttpClient } from './IHttpClient';
+export { IHttpRequest } from './request/IHttpRequest';
+export { HttpRequestBase, HttpRequestOptions, HttpRequestBaseOptions } from './request/HttpRequestBase';
+export { DefaultHttpRequest } from './request/DefaultHttpRequest';
+export { IHttpResponse } from './response/IHttpResponse';
+export { HttpResponseBase, HttpResponseOptions } from './response/HttpResponseBase';
+export { DefaultHttpResponse } from './response/DefaultHttpResponse';
+export { IBodyReader } from './body_reader/IBodyReader';
+export { StringBodyReader } from './body_reader/StringBodyReader';
+export * from './utils';

package/lib/http/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringBodyReader = exports.DefaultHttpResponse = exports.HttpResponseBase = exports.DefaultHttpRequest = exports.HttpRequestBase = void 0;
+var HttpRequestBase_1 = require("./request/HttpRequestBase");
+Object.defineProperty(exports, "HttpRequestBase", { enumerable: true, get: function () { return HttpRequestBase_1.HttpRequestBase; } });
+var DefaultHttpRequest_1 = require("./request/DefaultHttpRequest");
+Object.defineProperty(exports, "DefaultHttpRequest", { enumerable: true, get: function () { return DefaultHttpRequest_1.DefaultHttpRequest; } });
+var HttpResponseBase_1 = require("./response/HttpResponseBase");
+Object.defineProperty(exports, "HttpResponseBase", { enumerable: true, get: function () { return HttpResponseBase_1.HttpResponseBase; } });
+var DefaultHttpResponse_1 = require("./response/DefaultHttpResponse");
+Object.defineProperty(exports, "DefaultHttpResponse", { enumerable: true, get: function () { return DefaultHttpResponse_1.DefaultHttpResponse; } });
+var StringBodyReader_1 = require("./body_reader/StringBodyReader");
+Object.defineProperty(exports, "StringBodyReader", { enumerable: true, get: function () { return StringBodyReader_1.StringBodyReader; } });
+__exportStar(require("./utils"), exports);

package/lib/http/request/DefaultHttpRequest.d.ts

@@ -0,0 +1,5 @@
+import { HttpRequestBase, HttpRequestOptions } from './HttpRequestBase';
+export declare class DefaultHttpRequest extends HttpRequestBase<string, DefaultHttpRequest> {
+    constructor(url: string, options?: HttpRequestOptions<string>);
+    getUnderlyingRequest(): DefaultHttpRequest;
+}

package/lib/http/request/DefaultHttpRequest.js

@@ -0,0 +1,42 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultHttpRequest = void 0;
+var StringBodyReader_1 = require("../body_reader/StringBodyReader");
+var HttpRequestBase_1 = require("./HttpRequestBase");
+var DefaultHttpRequest = /** @class */ (function (_super) {
+    __extends(DefaultHttpRequest, _super);
+    function DefaultHttpRequest(url, options) {
+        return _super.call(this, url, __assign(__assign({}, options), { bodyReader: (options === null || options === void 0 ? void 0 : options.body) ? new StringBodyReader_1.StringBodyReader(options.body) : undefined })) || this;
+    }
+    DefaultHttpRequest.prototype.getUnderlyingRequest = function () {
+        return this;
+    };
+    return DefaultHttpRequest;
+}(HttpRequestBase_1.HttpRequestBase));
+exports.DefaultHttpRequest = DefaultHttpRequest;

package/lib/http/request/HttpRequestBase.d.ts

@@ -0,0 +1,24 @@
+import { HttpHeaders, HttpHeadersInit, HttpMethod, HttpBody } from '../utils';
+import { IHttpRequest } from './IHttpRequest';
+import { IBodyReader } from '../body_reader/IBodyReader';
+export declare type HttpRequestOptions<UnreadBodyType> = {
+    method?: HttpMethod;
+    headers?: HttpHeaders | HttpHeadersInit;
+    body?: UnreadBodyType;
+};
+export declare type HttpRequestBaseOptions<UnreadBodyType> = {
+    method?: HttpMethod;
+    headers?: HttpHeaders | HttpHeadersInit;
+    bodyReader?: IBodyReader<UnreadBodyType>;
+};
+export declare abstract class HttpRequestBase<UnreadBodyType, Req> implements IHttpRequest<UnreadBodyType, Req> {
+    readonly url: string;
+    readonly method: HttpMethod;
+    readonly headers: HttpHeaders;
+    protected readonly bodyReader: IBodyReader<UnreadBodyType>;
+    protected httpBody: HttpBody;
+    abstract getUnderlyingRequest(): Req;
+    protected constructor(url: string, options?: HttpRequestBaseOptions<UnreadBodyType>);
+    get body(): UnreadBodyType | string;
+    readBody(): Promise<HttpBody>;
+}