@shopify/shopify-api 6.0.0-rc1 → 6.0.0-rc3

package/CHANGELOG.md

@@ -7,6 +7,10 @@ and adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
 ## Unreleased
 
+## [6.0.0-rc2] - 2022-10-04
+
+- ⚠️ [Breaking] Final release candidate for `6.0.0` release, which is a complete breaking change across all surfaces of the library
+
 ## [5.1.0] - 2022-09-19
 
 - Increased tolerance for expired JWT session tokens from 5s to 10s [#462](https://github.com/Shopify/shopify-api-node/pull/462)

package/README.md

@@ -125,14 +125,15 @@ These are all the configuration values `shopifyApi` supports.
   - [Callback endpoint](docs/usage/oauth.md#callback-endpoint)
   - [Using sessions](docs/usage/oauth.md#using-sessions)
   - [Detecting scope changes](docs/usage/oauth.md#detecting-scope-changes)
-- [Make a REST API call](docs/usage/rest.md)
+- [REST Admin API client](docs/usage/rest.md)
   - [Using REST resources](docs/usage/rest.md#using-rest-resources)
-- [Make a GraphQL API call](docs/usage/graphql.md)
-- [Make a Storefront API call](docs/usage/storefront.md)
+- [GraphQL Admin API client](docs/usage/graphql.md)
+- [GraphqL Storefront API client](docs/usage/storefront.md)
 - [Webhooks](docs/usage/webhooks.md)
   - [Register a Webhook](docs/usage/webhooks.md#register-a-webhook)
   - [Process a Webhook](docs/usage/webhooks.md#process-a-webhook)
 - [Billing](docs/usage/billing.md)
+- [Adding custom runtimes](docs/usage/runtimes.md)
 - [Known issues and caveats](docs/issues.md)
   - [Notes on session handling](docs/issues.md#notes-on-session-handling)
 

package/dist/adapters/__e2etests__/test_apps/test-cf-worker-app.d.ts

@@ -0,0 +1,6 @@
+import '../../cf-worker';
+declare const _default: {
+    fetch(req: any, _env: any, _ctx: any): Promise<Response>;
+};
+export default _default;
+//# sourceMappingURL=test-cf-worker-app.d.ts.map

package/dist/adapters/__e2etests__/test_apps/test-cf-worker-app.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-cf-worker-app.d.ts","sourceRoot":"","sources":["../../../../src/adapters/__e2etests__/test_apps/test-cf-worker-app.ts"],"names":[],"mappings":"AAAA,OAAO,iBAAiB,CAAC;;eAsCN,GAAG,QAAQ,GAAG,QAAQ,GAAG;;AAD5C,wBA2KE"}

package/dist/adapters/__e2etests__/test_apps/test-cf-worker-app.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+require("../../cf-worker");
+var http_client_1 = require("../../../clients/http_client/http_client");
+var utils_1 = require("../utils");
+/* Codes for different Colours */
+var RED = '\x1b[31m';
+var GREEN = '\x1b[32m';
+var RESET = '\x1b[39m';
+var HttpClient = (0, http_client_1.createHttpClientClass)(utils_1.config, 'http');
+var defaultRetryTimer = HttpClient.RETRY_WAIT_TIME;
+var testCount = 0;
+function params(testRequest) {
+    return {
+        path: testRequest.url,
+        type: testRequest.bodyType,
+        data: JSON.stringify(testRequest.body),
+    };
+}
+function setRestClientRetryTime(time) {
+    // We de-type HttpClient here so we can alter its readonly time property
+    HttpClient.RETRY_WAIT_TIME = time;
+}
+/* eslint-disable-next-line import/no-anonymous-default-export */
+exports.default = {
+    fetch: function (req, _env, _ctx) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var apiServerPort, client, testConfig, testRequest, expectedResponse, tries, testPassed, timedOut_1, retryTimeout, testFailedDebug_1, response, _a, error_1;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        apiServerPort = parseInt(globalThis.HTTP_SERVER_PORT || '3000', 10);
+                        client = new HttpClient({
+                            domain: "localhost:".concat(apiServerPort),
+                        });
+                        if (!(req.method === 'POST')) return [3 /*break*/, 14];
+                        return [4 /*yield*/, req.json()];
+                    case 1:
+                        testConfig = _b.sent();
+                        testRequest = testConfig.testRequest;
+                        expectedResponse = testConfig.expectedResponse;
+                        tries = testRequest.tries || 1;
+                        testPassed = false;
+                        timedOut_1 = false;
+                        retryTimeout = void 0;
+                        testFailedDebug_1 = '';
+                        response = void 0;
+                        setRestClientRetryTime(defaultRetryTimer);
+                        testCount++;
+                        console.log("[cfWorker] testRequest #".concat(testCount, " = ").concat(JSON.stringify(testRequest, undefined, 2), "\n"));
+                        if (typeof testRequest.retryTimeoutTimer !== 'undefined') {
+                            setRestClientRetryTime(testRequest.retryTimeoutTimer);
+                            console.log("[cfWorker] RETRY_TIME_WAIT (BEFORE) = ".concat(HttpClient.RETRY_WAIT_TIME, "\n"));
+                            if (testRequest.retryTimeoutTimer !== 0) {
+                                console.log("[cfWorker] setting setTimeout @ ".concat(HttpClient.RETRY_WAIT_TIME, " ms\n"));
+                                retryTimeout = setTimeout(function () {
+                                    try {
+                                        throw new Error('Request was not retried within the interval defined by Retry-After, test failed');
+                                    }
+                                    catch (error) {
+                                        console.log("[cfWorker] ".concat(RED, "setTimeout fired!").concat(RESET, " @ ").concat(HttpClient.RETRY_WAIT_TIME, "\n"));
+                                        testFailedDebug_1 = JSON.stringify({
+                                            errorMessageReceived: error.message,
+                                        });
+                                        timedOut_1 = true;
+                                    }
+                                }, testRequest.retryTimeoutTimer);
+                            }
+                        }
+                        _a = testRequest.method.toLowerCase();
+                        switch (_a) {
+                            case 'get': return [3 /*break*/, 2];
+                            case 'post': return [3 /*break*/, 6];
+                            case 'put': return [3 /*break*/, 8];
+                            case 'delete': return [3 /*break*/, 10];
+                        }
+                        return [3 /*break*/, 12];
+                    case 2:
+                        _b.trys.push([2, 4, , 5]);
+                        return [4 /*yield*/, client.get({
+                                path: testRequest.url,
+                                tries: tries,
+                                extraHeaders: testRequest.headers,
+                            })];
+                    case 3:
+                        response = _b.sent();
+                        if (timedOut_1) {
+                            console.log("[cfWorker] timedOut=".concat(timedOut_1, ", testPassed=").concat(testPassed, ", testFailedDebug=").concat(testFailedDebug_1, "\n"));
+                        }
+                        else {
+                            testPassed =
+                                (0, utils_1.matchHeaders)(response.headers, expectedResponse.headers) && JSON.stringify(response.body) === expectedResponse.body;
+                            testFailedDebug_1 = JSON.stringify({
+                                bodyExpected: expectedResponse.body,
+                                bodyReceived: response.body,
+                                headersExpected: expectedResponse.headers,
+                                headersReceived: response.headers,
+                            });
+                        }
+                        return [3 /*break*/, 5];
+                    case 4:
+                        error_1 = _b.sent();
+                        testPassed = error_1.constructor.name.startsWith(expectedResponse.errorType);
+                        if (expectedResponse.errorType === 'HttpResponseError') {
+                            testPassed =
+                                testPassed &&
+                                    'response' in error_1 &&
+                                    'code' in error_1.response &&
+                                    error_1.response.code === expectedResponse.statusCode &&
+                                    'statusText' in error_1.response &&
+                                    error_1.response.statusText === expectedResponse.statusText;
+                        }
+                        if ('expectRequestId' in expectedResponse) {
+                            testPassed =
+                                testPassed &&
+                                    error_1.message.includes(expectedResponse.expectRequestId);
+                        }
+                        if ('errorMessage' in expectedResponse) {
+                            testPassed =
+                                testPassed && error_1.message === expectedResponse.errorMessage;
+                        }
+                        testFailedDebug_1 = JSON.stringify({
+                            statusCodeExpected: expectedResponse.statusCode,
+                            statusCodeReceived: error_1.code,
+                            statusTextExpected: expectedResponse.statusText,
+                            statusTextReceived: error_1.statusText,
+                            errorTypeExpected: expectedResponse.errorType,
+                            errorTypeReceived: error_1.constructor.name,
+                            errorMessageExpected: expectedResponse.errorMessage,
+                            errorMessageReceived: error_1.message,
+                        });
+                        return [3 /*break*/, 5];
+                    case 5: return [3 /*break*/, 13];
+                    case 6: return [4 /*yield*/, client.post(params(testRequest))];
+                    case 7:
+                        response = _b.sent();
+                        testPassed = JSON.stringify(response.body) === expectedResponse.body;
+                        return [3 /*break*/, 13];
+                    case 8: return [4 /*yield*/, client.put(params(testRequest))];
+                    case 9:
+                        response = _b.sent();
+                        testPassed = JSON.stringify(response.body) === expectedResponse.body;
+                        return [3 /*break*/, 13];
+                    case 10: return [4 /*yield*/, client.delete({ path: testRequest.url })];
+                    case 11:
+                        response = _b.sent();
+                        testPassed = JSON.stringify(response.body) === expectedResponse.body;
+                        return [3 /*break*/, 13];
+                    case 12:
+                        testPassed = false;
+                        _b.label = 13;
+                    case 13:
+                        if (typeof testRequest.retryTimeoutTimer !== 'undefined' &&
+                            testRequest.retryTimeoutTimer !== 0 &&
+                            typeof retryTimeout !== 'undefined') {
+                            clearTimeout(retryTimeout);
+                        }
+                        console.log("[cfWorker] test #".concat(testCount, " passed=").concat(testPassed ? GREEN : RED).concat(testPassed).concat(RESET, ", debug=").concat(JSON.stringify(testFailedDebug_1, undefined, 2), "\n"));
+                        if (testPassed) {
+                            return [2 /*return*/, new Response('Test passed!', { status: 200 })];
+                        }
+                        else {
+                            return [2 /*return*/, new Response(testFailedDebug_1, {
+                                    status: 500,
+                                    headers: {
+                                        'Content-Type': 'application/json',
+                                    },
+                                })];
+                        }
+                        return [3 /*break*/, 15];
+                    case 14: return [2 /*return*/, new Response('Ready!', { status: 200 })];
+                    case 15: return [2 /*return*/];
+                }
+            });
+        });
+    },
+};

package/dist/adapters/__e2etests__/test_apps/test-dummy-shopify-server.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=test-dummy-shopify-server.d.ts.map

package/dist/adapters/__e2etests__/test_apps/test-dummy-shopify-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-dummy-shopify-server.d.ts","sourceRoot":"","sources":["../../../../src/adapters/__e2etests__/test_apps/test-dummy-shopify-server.ts"],"names":[],"mappings":""}

package/dist/adapters/__e2etests__/test_apps/test-dummy-shopify-server.js

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* global process */
+var http_1 = require("http");
+var test_config_types_1 = require("../test_config_types");
+var utils_1 = require("../utils");
+// eslint-disable-next-line no-process-env
+var port = parseInt(process.env.HTTP_SERVER_PORT || '3000', 10);
+var errorStatusText = 'Did not work';
+var requestId = 'Request id header';
+var tests = {
+    200: {
+        expectedRequest: (0, test_config_types_1.initTestRequest)(),
+        testResponse: (0, test_config_types_1.initTestResponse)(),
+    },
+    custom: {
+        expectedRequest: (0, test_config_types_1.initTestRequest)({
+            headers: { 'X-Not-A-Real-Header': 'some_value' },
+        }),
+        testResponse: (0, test_config_types_1.initTestResponse)({
+            headers: { 'X-Not-A-Real-Header': 'some_value' },
+        }),
+    },
+    lowercaseua: {
+        expectedRequest: (0, test_config_types_1.initTestRequest)({
+            headers: { 'user-agent': 'My lowercase agent' },
+        }),
+        testResponse: (0, test_config_types_1.initTestResponse)({
+            headers: { 'user-agent': 'My lowercase agent' },
+        }),
+    },
+    uppercaseua: {
+        expectedRequest: (0, test_config_types_1.initTestRequest)({
+            headers: { 'User-Agent': 'My agent' },
+        }),
+        testResponse: (0, test_config_types_1.initTestResponse)({
+            headers: { 'User-Agent': 'My agent' },
+        }),
+    },
+    deprecatedget: {
+        expectedRequest: (0, test_config_types_1.initTestRequest)(),
+        testResponse: (0, test_config_types_1.initTestResponse)({
+            headers: {
+                'X-Shopify-API-Deprecated-Reason': 'This API endpoint has been deprecated',
+            },
+            body: JSON.stringify({ message: 'Some deprecated request' }),
+        }),
+    },
+    deprecatedpost: {
+        expectedRequest: (0, test_config_types_1.initTestRequest)(),
+        testResponse: (0, test_config_types_1.initTestResponse)({
+            headers: {
+                'X-Shopify-API-Deprecated-Reason': 'This API endpoint has been deprecated',
+            },
+            body: JSON.stringify({
+                message: 'Some deprecated post request',
+                body: {
+                    query: 'some query',
+                },
+            }),
+        }),
+    },
+    403: {
+        expectedRequest: (0, test_config_types_1.initTestRequest)(),
+        testResponse: (0, test_config_types_1.initTestResponse)({
+            statusCode: 403,
+            statusText: errorStatusText,
+            headers: { 'x-request-id': requestId },
+            body: JSON.stringify({ errors: 'Something went wrong!' }),
+        }),
+    },
+    404: {
+        expectedRequest: (0, test_config_types_1.initTestRequest)(),
+        testResponse: (0, test_config_types_1.initTestResponse)({
+            statusCode: 404,
+            statusText: errorStatusText,
+            body: JSON.stringify({}),
+        }),
+    },
+    417: {
+        expectedRequest: (0, test_config_types_1.initTestRequest)(),
+        testResponse: (0, test_config_types_1.initTestResponse)({
+            statusCode: 417,
+            statusText: 'Expectation Failed',
+        }),
+    },
+    429: {
+        expectedRequest: (0, test_config_types_1.initTestRequest)(),
+        testResponse: (0, test_config_types_1.initTestResponse)({
+            statusCode: 429,
+            statusText: errorStatusText,
+            headers: { 'x-request-id': requestId },
+            body: JSON.stringify({ errors: 'Something went wrong!' }),
+        }),
+    },
+    wait: {
+        expectedRequest: (0, test_config_types_1.initTestRequest)(),
+        testResponse: (0, test_config_types_1.initTestResponse)({
+            statusCode: 429,
+            statusText: errorStatusText,
+            headers: { 'Retry-After': (0.1).toString() },
+            body: JSON.stringify({ errors: 'Something went wrong!' }),
+        }),
+    },
+    500: {
+        expectedRequest: (0, test_config_types_1.initTestRequest)(),
+        testResponse: (0, test_config_types_1.initTestResponse)({
+            statusCode: 500,
+            statusText: errorStatusText,
+            headers: { 'x-request-id': requestId },
+            body: JSON.stringify({}),
+        }),
+    },
+    error: {
+        expectedRequest: (0, test_config_types_1.initTestRequest)(),
+        testResponse: (0, test_config_types_1.initTestResponse)({
+            statusCode: 500,
+            statusText: errorStatusText,
+            body: JSON.stringify({ errors: 'Something went wrong' }),
+        }),
+    },
+    detailederror: {
+        expectedRequest: (0, test_config_types_1.initTestRequest)(),
+        testResponse: (0, test_config_types_1.initTestResponse)({
+            statusCode: 500,
+            statusText: errorStatusText,
+            body: JSON.stringify({
+                errors: { title: 'Invalid title', description: 'Invalid description' },
+            }),
+        }),
+    },
+};
+var retryCount = 0;
+var server = (0, http_1.createServer)(function (req, res) {
+    var _a;
+    var lookup = (_a = req.url) === null || _a === void 0 ? void 0 : _a.match(/^\/url\/path\/([a-z0-9]*)$/);
+    var receivedHeaders = req.headers;
+    var code = lookup ? lookup[1] : '200';
+    var test = tests[code] || tests['200'];
+    var expectedRequest = test.expectedRequest;
+    var testResponse = test.testResponse;
+    if ((0, utils_1.matchHeaders)(receivedHeaders, expectedRequest.headers)) {
+        if (code === 'retries' && retryCount < 2) {
+            testResponse = tests['429'].testResponse;
+            retryCount += 1;
+        }
+        if (code === 'retrythenfail') {
+            if (retryCount === 0) {
+                testResponse = tests['500'].testResponse;
+                retryCount = 1;
+            }
+            else {
+                testResponse = tests['403'].testResponse;
+                // this is the end of the test, reset the counter
+                retryCount = 0;
+            }
+        }
+        if (code === 'retrythensuccess') {
+            if (retryCount === 0) {
+                testResponse = tests.wait.testResponse;
+                retryCount = 1;
+            }
+            else {
+                // this is the end of the test, reset the counter; response already defaults to success
+                retryCount = 0;
+            }
+        }
+        if (code === 'maxretries') {
+            testResponse = tests['500'].testResponse;
+        }
+    }
+    else {
+        // return an "expectation failed" message
+        testResponse = tests['417'].testResponse;
+        testResponse.body = JSON.stringify({
+            errors: {
+                message: 'There was a header mismatch between expected request and received request',
+                receivedHeaders: receivedHeaders,
+                expectedHeaders: expectedRequest.headers,
+            },
+        });
+    }
+    // console.log(response);
+    res.writeHead(testResponse.statusCode, testResponse.statusText, testResponse.headers);
+    res.end(testResponse.body);
+    // reset counters
+    if (code !== 'retries' && retryCount === 2) {
+        retryCount = 0;
+    }
+    if (code === 'endtest') {
+        handle(0);
+    }
+});
+function handle(_signal) {
+    process.exit(0);
+}
+process.on('SIGINT', handle);
+process.on('SIGTERM', handle);
+server.listen(port, function () {
+    console.log("Listening on :".concat(port));
+});

package/dist/adapters/__e2etests__/test_apps/test-node-app.d.ts

@@ -0,0 +1,2 @@
+import '../../node';
+//# sourceMappingURL=test-node-app.d.ts.map

package/dist/adapters/__e2etests__/test_apps/test-node-app.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-node-app.d.ts","sourceRoot":"","sources":["../../../../src/adapters/__e2etests__/test_apps/test-node-app.ts"],"names":[],"mappings":"AAEA,OAAO,YAAY,CAAC"}

package/dist/adapters/__e2etests__/test_apps/test-node-app.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var http_1 = require("http");
+require("../../node");
+var http_client_1 = require("../../../clients/http_client/http_client");
+var utils_1 = require("../utils");
+/* Codes for different Colours */
+var RED = '\x1b[31m';
+var GREEN = '\x1b[32m';
+var RESET = '\x1b[39m';
+var HttpClient = (0, http_client_1.createHttpClientClass)(utils_1.config, 'http');
+/* eslint-disable no-process-env */
+var apiServerPort = parseInt(process.env.HTTP_SERVER_PORT || '3000', 10);
+var appPort = parseInt(process.env.PORT || '8787', 10);
+/* eslint-enable no-process-env */
+var apiServer = "localhost:".concat(apiServerPort);
+var client = new HttpClient({ domain: apiServer });
+var defaultRetryTimer = HttpClient.RETRY_WAIT_TIME;
+var testCount = 0;
+var server = (0, http_1.createServer)(function (request, appResponse) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+    var testConfig, testRequest, expectedResponse, tries, params, testPassed, timedOut_1, testFailedDebug_1, response, retryTimeout, _a, error_1;
+    return tslib_1.__generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                if (!(request.method === 'POST')) return [3 /*break*/, 14];
+                return [4 /*yield*/, getJSONDataFromRequestStream(request)];
+            case 1:
+                testConfig = _b.sent();
+                testRequest = testConfig.testRequest;
+                expectedResponse = testConfig.expectedResponse;
+                tries = testRequest.tries || 1;
+                params = {
+                    path: testRequest.url,
+                    type: testRequest.bodyType,
+                    data: JSON.stringify(testRequest.body),
+                };
+                testPassed = false;
+                timedOut_1 = false;
+                testFailedDebug_1 = '';
+                response = void 0;
+                retryTimeout = void 0;
+                setRestClientRetryTime(defaultRetryTimer);
+                testCount++;
+                console.log("[node] testRequest #".concat(testCount, " = ").concat(JSON.stringify(testRequest, undefined, 2), "\n"));
+                if (typeof testRequest.retryTimeoutTimer !== 'undefined') {
+                    setRestClientRetryTime(testRequest.retryTimeoutTimer);
+                    console.log("[node] RETRY_TIME_WAIT (BEFORE) = ".concat(HttpClient.RETRY_WAIT_TIME, " ms\n\n"));
+                    if (testRequest.retryTimeoutTimer !== 0) {
+                        console.log("[node] setting setTimeout @ ".concat(HttpClient.RETRY_WAIT_TIME, " ms\n"));
+                        retryTimeout = setTimeout(function () {
+                            try {
+                                throw new Error('Request was not retried within the interval defined by Retry-After, test failed');
+                            }
+                            catch (error) {
+                                console.log("[node] ".concat(RED, "setTimeout fired!").concat(RESET, " @ ").concat(HttpClient.RETRY_WAIT_TIME, "\n"));
+                                testFailedDebug_1 = JSON.stringify({
+                                    errorMessageReceived: error.message,
+                                });
+                                timedOut_1 = true;
+                            }
+                        }, testRequest.retryTimeoutTimer);
+                    }
+                }
+                _a = testRequest.method.toLowerCase();
+                switch (_a) {
+                    case 'get': return [3 /*break*/, 2];
+                    case 'post': return [3 /*break*/, 6];
+                    case 'put': return [3 /*break*/, 8];
+                    case 'delete': return [3 /*break*/, 10];
+                }
+                return [3 /*break*/, 12];
+            case 2:
+                _b.trys.push([2, 4, , 5]);
+                return [4 /*yield*/, client.get({
+                        path: testRequest.url,
+                        tries: tries,
+                        extraHeaders: testRequest.headers,
+                    })];
+            case 3:
+                response = _b.sent();
+                if (timedOut_1) {
+                    console.log("[node] timedOut=".concat(timedOut_1, ", testPassed=").concat(testPassed, ", testFailedDebug=").concat(testFailedDebug_1, "\n"));
+                }
+                else {
+                    testPassed =
+                        (0, utils_1.matchHeaders)(response.headers, expectedResponse.headers) && JSON.stringify(response.body) === expectedResponse.body;
+                    testFailedDebug_1 = JSON.stringify({
+                        bodyExpected: expectedResponse.body,
+                        bodyReceived: response.body,
+                        headersExpected: expectedResponse.headers,
+                        headersReceived: response.headers,
+                    });
+                }
+                return [3 /*break*/, 5];
+            case 4:
+                error_1 = _b.sent();
+                testPassed = error_1.constructor.name.startsWith(expectedResponse.errorType);
+                if (expectedResponse.errorType === 'HttpResponseError') {
+                    testPassed =
+                        testPassed &&
+                            'response' in error_1 &&
+                            'code' in error_1.response &&
+                            error_1.response.code === expectedResponse.statusCode &&
+                            'statusText' in error_1.response &&
+                            error_1.response.statusText === expectedResponse.statusText;
+                }
+                if ('expectRequestId' in expectedResponse) {
+                    testPassed =
+                        testPassed &&
+                            error_1.message.includes(expectedResponse.expectRequestId);
+                }
+                if ('errorMessage' in expectedResponse) {
+                    testPassed =
+                        testPassed && error_1.message === expectedResponse.errorMessage;
+                }
+                testFailedDebug_1 = JSON.stringify({
+                    statusCodeExpected: expectedResponse.statusCode,
+                    statusCodeReceived: error_1.code,
+                    statusTextExpected: expectedResponse.statusText,
+                    statusTextReceived: error_1.statusText,
+                    errorTypeExpected: expectedResponse.errorType,
+                    errorTypeReceived: error_1.constructor.name,
+                    errorMessageExpected: expectedResponse.errorMessage,
+                    errorMessageReceived: error_1.message,
+                });
+                return [3 /*break*/, 5];
+            case 5: return [3 /*break*/, 13];
+            case 6: return [4 /*yield*/, client.post(params)];
+            case 7:
+                response = _b.sent();
+                testPassed = JSON.stringify(response.body) === expectedResponse.body;
+                return [3 /*break*/, 13];
+            case 8: return [4 /*yield*/, client.put(params)];
+            case 9:
+                response = _b.sent();
+                testPassed = JSON.stringify(response.body) === expectedResponse.body;
+                return [3 /*break*/, 13];
+            case 10: return [4 /*yield*/, client.delete({ path: testRequest.url })];
+            case 11:
+                response = _b.sent();
+                testPassed = JSON.stringify(response.body) === expectedResponse.body;
+                return [3 /*break*/, 13];
+            case 12:
+                testPassed = false;
+                _b.label = 13;
+            case 13:
+                if (typeof testRequest.retryTimeoutTimer !== 'undefined' &&
+                    testRequest.retryTimeoutTimer !== 0 &&
+                    typeof retryTimeout !== 'undefined') {
+                    clearTimeout(retryTimeout);
+                }
+                console.log("[node] test #".concat(testCount, " passed=").concat(testPassed ? GREEN : RED).concat(testPassed).concat(RESET, ", debug=").concat(JSON.stringify(testFailedDebug_1, undefined, 2), "\n"));
+                if (testPassed) {
+                    appResponse.statusCode = 200;
+                    appResponse.end('Test passed!');
+                }
+                else {
+                    appResponse.statusCode = 500;
+                    appResponse.setHeader('Content-Type', 'application/json');
+                    appResponse.end(testFailedDebug_1);
+                }
+                return [3 /*break*/, 15];
+            case 14:
+                appResponse.statusCode = 200;
+                appResponse.end('Ready!');
+                _b.label = 15;
+            case 15: return [2 /*return*/];
+        }
+    });
+}); });
+function getJSONDataFromRequestStream(request) {
+    return new Promise(function (resolve) {
+        var chunks = [];
+        request.on('data', function (chunk) {
+            chunks.push(chunk);
+        });
+        request.on('end', function () {
+            resolve(JSON.parse(Buffer.concat(chunks).toString()));
+        });
+    });
+}
+function handle(_signal) {
+    process.exit(0);
+}
+function setRestClientRetryTime(time) {
+    // We de-type HttpClient here so we can alter its readonly time property
+    HttpClient.RETRY_WAIT_TIME = time;
+}
+process.on('SIGINT', handle);
+process.on('SIGTERM', handle);
+server.listen(appPort, function () {
+    console.log("Listening on :".concat(appPort));
+});

package/dist/adapters/__e2etests__/test_config_types.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="node" />
+import { ChildProcess } from 'child_process';
+import { NormalizedRequest, NormalizedResponse } from '../../runtime/http';
+import { DataType } from '../../clients/http_client/types';
+export interface TestRequest extends NormalizedRequest {
+    bodyType?: DataType;
+    tries?: number;
+    query?: string;
+    retryTimeoutTimer?: number;
+}
+export interface TestResponse extends NormalizedResponse {
+    errorType?: string;
+    errorMessage?: string;
+    expectRequestId?: string;
+}
+export interface TestConfig {
+    testRequest: TestRequest;
+    expectedResponse: TestResponse;
+}
+export declare function initTestRequest(options?: Partial<TestRequest>): TestRequest;
+export declare function initTestResponse(options?: Partial<TestResponse>): TestResponse;
+export interface E2eTestEnvironment {
+    name: string;
+    domain: string;
+    dummyServerPort: string;
+    process: ChildProcess;
+    testable: boolean;
+    ready: boolean;
+}
+//# sourceMappingURL=test_config_types.d.ts.map

package/dist/adapters/__e2etests__/test_config_types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test_config_types.d.ts","sourceRoot":"","sources":["../../../src/adapters/__e2etests__/test_config_types.ts"],"names":[],"mappings":";AAAA,OAAO,EAAC,YAAY,EAAC,MAAM,eAAe,CAAC;AAE3C,OAAO,EAAC,iBAAiB,EAAE,kBAAkB,EAAC,MAAM,oBAAoB,CAAC;AACzE,OAAO,EAAC,QAAQ,EAAC,MAAM,iCAAiC,CAAC;AAEzD,MAAM,WAAW,WAAY,SAAQ,iBAAiB;IACpD,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AACD,MAAM,WAAW,YAAa,SAAQ,kBAAkB;IACtD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,UAAU;IACzB,WAAW,EAAE,WAAW,CAAC;IACzB,gBAAgB,EAAE,YAAY,CAAC;CAChC;AAED,wBAAgB,eAAe,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,GAAG,WAAW,CAU3E;AAED,wBAAgB,gBAAgB,CAC9B,OAAO,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,GAC9B,YAAY,CAYd;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,YAAY,CAAC;IACtB,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,EAAE,OAAO,CAAC;CAChB"}