perimeterx-js-core 0.2.0 → 0.4.0

package/lib/filter/DefaultFilter.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefaultFilter = void 0;
-var http_1 = require("../http");
 var utils_1 = require("../utils");
 var FilterReason_1 = require("./FilterReason");
+var http_1 = require("../http");
 var DefaultFilter = /** @class */ (function () {
     function DefaultFilter(config, ipRangeChecker) {
         if (ipRangeChecker === void 0) { ipRangeChecker = new utils_1.DefaultIpRangeChecker(); }

package/lib/first_party/DefaultFirstParty.d.ts

@@ -1,12 +1,13 @@
 import { IConfiguration } from '../config';
 import { IContext } from '../context/IContext';
-import { IHttpClient, IHttpResponse } from '../http';
 import { IFirstParty } from './IFirstParty';
+import { IHttpClient } from '../http';
+import { IMinimalResponse } from '../http';
 export declare class DefaultFirstParty implements IFirstParty {
     private readonly config;
     private readonly httpClient;
     constructor(config: IConfiguration, httpClient: IHttpClient);
-    handleFirstPartyRequest(context: IContext): Promise<IHttpResponse>;
+    handleFirstPartyRequest(context: IContext): Promise<IMinimalResponse>;
     private proxySensorScriptRequest;
     private proxyXhrRequest;
     private static getDefaultXhrResponse;

package/lib/first_party/DefaultFirstParty.js

@@ -1,4 +1,15 @@
 "use strict";
+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);
+};
 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) {
@@ -41,6 +52,9 @@ var utils_1 = require("../utils");
 var http_1 = require("../http");
 var utils_2 = require("./utils");
 var constants_1 = require("./constants");
+var http_2 = require("../http");
+var http_3 = require("../http");
+var minimalResponseUtils = require("../http/utils/MinimalResponseUtils");
 var DefaultFirstParty = /** @class */ (function () {
     function DefaultFirstParty(config, httpClient) {
         this.config = config;
@@ -80,15 +94,13 @@ var DefaultFirstParty = /** @class */ (function () {
                 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)];
+                            return [2 /*return*/, new http_3.MinimalResponseImpl(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)];
+                        return [2 /*return*/, response ? response : new http_3.MinimalResponseImpl(constants_1.DEFAULT_CLIENT_RESPONSE_OPTIONS)];
                 }
             });
         });
@@ -115,7 +127,11 @@ var DefaultFirstParty = /** @class */ (function () {
     };
     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);
+        return new http_3.MinimalResponseImpl({
+            body: content,
+            status: options.status,
+            headers: options.headers,
+        });
     };
     DefaultFirstParty.prototype.proxyCaptchaScriptRequest = function (context, prefix) {
         return __awaiter(this, void 0, void 0, function () {
@@ -124,15 +140,13 @@ var DefaultFirstParty = /** @class */ (function () {
                 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)];
+                            return [2 /*return*/, new http_3.MinimalResponseImpl(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)];
+                        return [2 /*return*/, response ? response : new http_3.MinimalResponseImpl(constants_1.DEFAULT_CLIENT_RESPONSE_OPTIONS)];
                 }
             });
         });
@@ -140,20 +154,24 @@ var DefaultFirstParty = /** @class */ (function () {
     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) {
+            var request, _b, _c, e_1;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
                     case 0:
-                        _b.trys.push([0, 2, , 3]);
-                        firstPartyReq = requestData.request;
-                        firstPartyReq.url = url;
-                        firstPartyReq.headers = this.prepareFirstPartyHeaders(url, requestData, vid);
+                        _d.trys.push([0, 2, , 3]);
+                        request = new http_2.OutgoingRequestImpl({
+                            url: url,
+                            method: requestData.request.method,
+                            headers: this.prepareFirstPartyHeaders(url, requestData, vid),
+                            body: requestData.request.body,
+                        });
                         this.config.logger.debug('forwarding to ' + url);
-                        return [4 /*yield*/, this.httpClient.send(firstPartyReq)];
-                    case 1: return [2 /*return*/, _b.sent()];
+                        _c = (_b = minimalResponseUtils).from;
+                        return [4 /*yield*/, this.httpClient.send(request)];
+                    case 1: return [2 /*return*/, _c.apply(_b, [_d.sent()])];
                     case 2:
-                        e_1 = _b.sent();
-                        this.config.logger.debug("failed sending first party request to ".concat(url));
+                        e_1 = _d.sent();
+                        this.config.logger.debug("failed sending first party request to ".concat(url, ": ").concat(e_1));
                         return [2 /*return*/, null];
                     case 3: return [2 /*return*/];
                 }
@@ -161,14 +179,14 @@ var DefaultFirstParty = /** @class */ (function () {
         });
     };
     DefaultFirstParty.prototype.prepareFirstPartyHeaders = function (url, requestData, vid) {
-        var headers = requestData.headers.copy();
+        var headers = __assign({}, requestData.headers);
         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));
+                headers[http_1.COOKIE_HEADER_NAME] = (headers[http_1.COOKIE_HEADER_NAME] || []).concat(["pxvid=".concat(vid)]);
             }
         }
         catch (e) {
@@ -177,23 +195,15 @@ var DefaultFirstParty = /** @class */ (function () {
         return headers;
     };
     DefaultFirstParty.prototype.setHostHeader = function (headers, url) {
-        var host = new URL(url).host;
-        headers.set(http_1.HOST_HEADER_NAME, host);
+        headers[http_1.HOST_HEADER_NAME] = [new URL(url).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);
+        var xffValue = headers[http_1.X_FORWARDED_FOR_HEADER_NAME] || [];
+        headers[http_1.X_FORWARDED_FOR_HEADER_NAME] = xffValue.concat([ip]);
     };
     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);
+        headers[constants_1.FIRST_PARTY_HEADER_NAME] = [constants_1.FIRST_PARTY_HEADER_VALUE];
+        headers[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");

package/lib/first_party/IFirstParty.d.ts

@@ -1,9 +1,9 @@
 import { IContext } from '../context';
-import { IHttpResponse } from '../http';
+import { IMinimalResponse } 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>;
+    handleFirstPartyRequest(context: IContext): Promise<IMinimalResponse>;
 }

package/lib/first_party/constants.d.ts

@@ -1,17 +1,10 @@
 import { ContentType } from '../http';
+import { MinimalResponseOptions } 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_CLIENT_RESPONSE_OPTIONS: MinimalResponseOptions;
 export declare const DEFAULT_XHR_RESPONSE: {
     content: string;
     options: {

package/lib/first_party/constants.js

@@ -1,7 +1,7 @@
 "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;
+exports.DEFAULT_GIF_RESPONSE = exports.DEFAULT_XHR_RESPONSE = exports.DEFAULT_CLIENT_RESPONSE_OPTIONS = 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,
@@ -10,14 +10,12 @@ exports.EMPTY_GIF = [
 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_CLIENT_RESPONSE_OPTIONS = {
+    body: '',
+    status: 200,
+    headers: (_a = {},
+        _a[http_1.CONTENT_TYPE_HEADER_NAME] = [http_1.ContentType.APPLICATION_JAVASCRIPT],
+        _a),
 };
 exports.DEFAULT_XHR_RESPONSE = {
     content: '{}',

package/lib/graphql/DefaultGraphQLParser.d.ts

@@ -0,0 +1,19 @@
+import { IContext } from '../context/IContext';
+import { IConfiguration } from '../config';
+import { IGraphQLParser } from './IGraphQLParser';
+export declare class DefaultGraphQLParser implements IGraphQLParser {
+    private readonly logger;
+    private readonly graphqlRoutes;
+    private readonly sensitiveOperationTypes;
+    private readonly sensitiveOperationNames;
+    constructor(config: IConfiguration);
+    isGraphQLRequest({ requestData }: IContext): boolean;
+    parseGraphQLRequest(context: IContext): Promise<boolean>;
+    private getGraphQLOperationsFromBody;
+    private parseGraphQLOperations;
+    private parseGraphQlOperation;
+    private getOperationNameToTypeMap;
+    private getGraphQLData;
+    private isSensitiveOperation;
+    private extractGraphQLVariableNames;
+}

package/lib/graphql/DefaultGraphQLParser.js

@@ -0,0 +1,179 @@
+"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.DefaultGraphQLParser = void 0;
+var GraphQLOperationType_1 = require("./model/GraphQLOperationType");
+var utils_1 = require("../utils");
+var http_1 = require("../http");
+var DefaultGraphQLParser = /** @class */ (function () {
+    function DefaultGraphQLParser(config) {
+        this.logger = config.logger;
+        this.graphqlRoutes = config.graphqlRoutes;
+        this.sensitiveOperationNames = config.sensitiveGraphqlOperationNames;
+        this.sensitiveOperationTypes = config.sensitiveGraphqlOperationTypes;
+    }
+    DefaultGraphQLParser.prototype.isGraphQLRequest = function (_a) {
+        var requestData = _a.requestData;
+        return (requestData.method === http_1.HttpMethod.POST && (0, utils_1.isRouteInPatterns)(requestData.url.pathname, this.graphqlRoutes));
+    };
+    DefaultGraphQLParser.prototype.parseGraphQLRequest = function (context) {
+        return __awaiter(this, void 0, void 0, function () {
+            var graphQLOperations, data, e_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.getGraphQLOperationsFromBody(context.requestData)];
+                    case 1:
+                        graphQLOperations = _a.sent();
+                        if (!graphQLOperations) {
+                            this.logger.debug('unable to get graphql operations from request body');
+                            return [2 /*return*/, false];
+                        }
+                        data = this.parseGraphQLOperations(graphQLOperations);
+                        if (!data || data.length === 0) {
+                            this.logger.debug('unable to parse graphql operations');
+                            return [2 /*return*/, false];
+                        }
+                        this.logger.debug("".concat(data.length, " graphql operation").concat(data.length === 1 ? '' : 's', " parsed successfully"));
+                        context.graphqlData = data;
+                        context.isSensitiveRequest = context.isSensitiveRequest || data.some(function (operation) { return operation.sensitive; });
+                        return [2 /*return*/, true];
+                    case 2:
+                        e_1 = _a.sent();
+                        this.logger.debug("error parsing graphql request: ".concat(e_1));
+                        return [2 /*return*/, false];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    DefaultGraphQLParser.prototype.getGraphQLOperationsFromBody = function (_a) {
+        var request = _a.request;
+        return __awaiter(this, void 0, void 0, function () {
+            var body;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, request.json().catch(function (e) {
+                            _this.logger.debug("unable to parse string body: ".concat(e));
+                            return null;
+                        })];
+                    case 1:
+                        body = _b.sent();
+                        if (!body) {
+                            return [2 /*return*/, null];
+                        }
+                        return [2 /*return*/, Array.isArray(body) ? body : [body]];
+                }
+            });
+        });
+    };
+    DefaultGraphQLParser.prototype.parseGraphQLOperations = function (operations) {
+        var _this = this;
+        return operations.map(function (operation) { return _this.parseGraphQlOperation(operation); }).filter(function (x) { return x; });
+    };
+    DefaultGraphQLParser.prototype.parseGraphQlOperation = function (operation) {
+        if (!operation.query || typeof operation.query !== 'string') {
+            return null;
+        }
+        var operationNameToTypeMap = this.getOperationNameToTypeMap(operation.query);
+        if (!operationNameToTypeMap) {
+            return null;
+        }
+        return this.getGraphQLData(operationNameToTypeMap, operation);
+    };
+    DefaultGraphQLParser.prototype.getOperationNameToTypeMap = function (query) {
+        var operationTypesString = Object.values(GraphQLOperationType_1.GraphQLOperationType).join('|');
+        var pattern = new RegExp("\\s*(".concat(operationTypesString, ")\\s+(\\w+)"), 'gm');
+        var match;
+        var map = {};
+        while ((match = pattern.exec(query)) !== null) {
+            var operationType = match[1];
+            var operationName = match[2];
+            if (map[operationName]) {
+                // query contains two operations with the same name which is illegal
+                return null;
+            }
+            else {
+                map[operationName] = operationType;
+            }
+        }
+        return map;
+    };
+    DefaultGraphQLParser.prototype.getGraphQLData = function (operationNameToTypeMap, operation) {
+        var name = operation.operationName ||
+            (Object.keys(operationNameToTypeMap).length === 1 ? Object.keys(operationNameToTypeMap)[0] : undefined);
+        var type = operationNameToTypeMap[name];
+        if (!type && /^\s*{/.test(operation.query)) {
+            type = GraphQLOperationType_1.GraphQLOperationType.QUERY;
+        }
+        if (!type) {
+            return null;
+        }
+        var data = { name: name, type: type };
+        if (this.isSensitiveOperation(name, type)) {
+            data.sensitive = true;
+        }
+        if (operation.variables && typeof operation.variables === 'object') {
+            data.variables = this.extractGraphQLVariableNames(operation.variables);
+        }
+        return data;
+    };
+    DefaultGraphQLParser.prototype.isSensitiveOperation = function (operationName, operationType) {
+        return (this.sensitiveOperationTypes.some(function (type) { return type === operationType; }) ||
+            this.sensitiveOperationNames.some(function (name) { return name === operationName; }));
+    };
+    DefaultGraphQLParser.prototype.extractGraphQLVariableNames = function (variables) {
+        var processVariables = function (variablesObj, prefix) {
+            return Object.entries(variablesObj).reduce(function (total, _a) {
+                var key = _a[0], value = _a[1];
+                if (!value || typeof value !== 'object' || Object.keys(value).length === 0) {
+                    total.push(prefix + key);
+                    return total;
+                }
+                else {
+                    return total.concat(processVariables(value, "".concat(prefix).concat(key, ".")));
+                }
+            }, []);
+        };
+        return processVariables(variables, '');
+    };
+    return DefaultGraphQLParser;
+}());
+exports.DefaultGraphQLParser = DefaultGraphQLParser;

package/lib/graphql/IGraphQLParser.d.ts

@@ -0,0 +1,5 @@
+import { IContext } from '../context';
+export interface IGraphQLParser {
+    isGraphQLRequest(context: IContext): boolean;
+    parseGraphQLRequest(context: IContext): Promise<boolean>;
+}

package/lib/graphql/index.d.ts

@@ -0,0 +1,5 @@
+export { GraphQLOperationType } from './model/GraphQLOperationType';
+export { GraphQLOperation } from './model/GraphQLOperation';
+export { GraphQLData } from './model/GraphQLData';
+export { IGraphQLParser } from './IGraphQLParser';
+export { DefaultGraphQLParser } from './DefaultGraphQLParser';

package/lib/graphql/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultGraphQLParser = exports.GraphQLOperationType = void 0;
+var GraphQLOperationType_1 = require("./model/GraphQLOperationType");
+Object.defineProperty(exports, "GraphQLOperationType", { enumerable: true, get: function () { return GraphQLOperationType_1.GraphQLOperationType; } });
+var DefaultGraphQLParser_1 = require("./DefaultGraphQLParser");
+Object.defineProperty(exports, "DefaultGraphQLParser", { enumerable: true, get: function () { return DefaultGraphQLParser_1.DefaultGraphQLParser; } });

package/lib/graphql/model/GraphQLData.d.ts

@@ -0,0 +1,7 @@
+import { GraphQLOperationType } from './GraphQLOperationType';
+export declare type GraphQLData = {
+    type: GraphQLOperationType;
+    name?: string;
+    sensitive?: boolean;
+    variables?: string[];
+};

package/lib/graphql/model/GraphQLOperation.d.ts

@@ -0,0 +1,5 @@
+export declare type GraphQLOperation = {
+    query: string;
+    operationName?: string;
+    variables?: Record<string, unknown>;
+};

package/lib/graphql/model/GraphQLOperationType.d.ts

@@ -0,0 +1,5 @@
+export declare enum GraphQLOperationType {
+    QUERY = "query",
+    MUTATION = "mutation",
+    SUBSCRIPTION = "subscription"
+}

package/lib/graphql/model/GraphQLOperationType.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphQLOperationType = void 0;
+var GraphQLOperationType;
+(function (GraphQLOperationType) {
+    GraphQLOperationType["QUERY"] = "query";
+    GraphQLOperationType["MUTATION"] = "mutation";
+    GraphQLOperationType["SUBSCRIPTION"] = "subscription";
+})(GraphQLOperationType = exports.GraphQLOperationType || (exports.GraphQLOperationType = {}));

package/lib/http/impl/MinimalResponseImpl.d.ts

@@ -0,0 +1,13 @@
+import { IMinimalResponse } from '../interfaces';
+import { ReadOnlyHeaders } from '../interfaces';
+export declare type MinimalResponseOptions = {
+    status?: number;
+    headers?: ReadOnlyHeaders;
+    body: any;
+};
+export declare class MinimalResponseImpl implements IMinimalResponse {
+    readonly body: any;
+    readonly headers: ReadOnlyHeaders;
+    readonly status: number;
+    constructor(options: MinimalResponseOptions);
+}

package/lib/http/impl/MinimalResponseImpl.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MinimalResponseImpl = void 0;
+var MinimalResponseImpl = /** @class */ (function () {
+    function MinimalResponseImpl(options) {
+        this.body = options.body;
+        this.headers = options.headers || {};
+        this.status = options.status || 200;
+    }
+    return MinimalResponseImpl;
+}());
+exports.MinimalResponseImpl = MinimalResponseImpl;

package/lib/http/impl/OutgoingRequestImpl.d.ts

@@ -0,0 +1,14 @@
+import { ReadOnlyHeaders, HttpMethod, IOutgoingRequest } from '..';
+export declare type OutGoingRequestImplOptions = {
+    url: string;
+    method?: HttpMethod | string;
+    headers?: ReadOnlyHeaders;
+    body?: any;
+};
+export declare class OutgoingRequestImpl implements IOutgoingRequest {
+    readonly body: any;
+    readonly url: string;
+    readonly method: HttpMethod;
+    readonly headers: ReadOnlyHeaders;
+    constructor(options: OutGoingRequestImplOptions);
+}

package/lib/http/impl/OutgoingRequestImpl.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OutgoingRequestImpl = void 0;
+var __1 = require("..");
+var OutgoingRequestImpl = /** @class */ (function () {
+    function OutgoingRequestImpl(options) {
+        this.url = options.url;
+        this.method = options.method || __1.HttpMethod.GET;
+        this.headers = options.headers || {};
+        this.body = options.body;
+    }
+    return OutgoingRequestImpl;
+}());
+exports.OutgoingRequestImpl = OutgoingRequestImpl;

package/lib/http/impl/index.d.ts

@@ -0,0 +1,2 @@
+export * from './MinimalResponseImpl';
+export * from './OutgoingRequestImpl';

package/lib/http/impl/index.js

@@ -0,0 +1,18 @@
+"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 });
+__exportStar(require("./MinimalResponseImpl"), exports);
+__exportStar(require("./OutgoingRequestImpl"), exports);

package/lib/http/index.d.ts

@@ -1,10 +1,3 @@
-export { IHttpClient, HttpSendOptions } 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';
+export * from './interfaces';
+export * from './impl';

package/lib/http/index.js

@@ -14,15 +14,6 @@ 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);
+__exportStar(require("./interfaces"), exports);
+__exportStar(require("./impl"), exports);

package/lib/http/interfaces/IBody.d.ts

@@ -0,0 +1,26 @@
+export interface IBody {
+    /**
+     * the unread body.
+     */
+    readonly body: any;
+    /**
+     * Converts the body to json
+     */
+    json(): Promise<any>;
+    /**
+     * Converts the body to formData
+     */
+    formData(): Promise<FormData>;
+    /**
+     * Converts the body to text
+     */
+    text(): Promise<string>;
+    /**
+     * Converts the body to blob
+     */
+    blob(): Promise<Blob>;
+    /**
+     * Converts the body to arrayBuffer
+     */
+    arrayBuffer(): Promise<ArrayBuffer>;
+}