@shopify/shopify-api 5.1.0 → 6.0.0-rc2

package/dist/adapters/__e2etests__/test_suite.js

@@ -0,0 +1,314 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testSuite = void 0;
+var tslib_1 = require("tslib");
+var types_1 = require("../../clients/http_client/types");
+var processed_query_1 = tslib_1.__importDefault(require("../../utils/processed-query"));
+var test_config_types_1 = require("./test_config_types");
+var postData = {
+    title: 'Test product',
+    amount: 10,
+};
+var putData = {
+    title: 'Test product',
+    amount: 10,
+};
+var graphqlQuery = "\n  query {\n    webhookSubscriptions(first:5) {\n      edges {\n        node {\n          id\n          endpoint\n        }\n      }\n    }\n  }\n  ";
+exports.testSuite = [
+    {
+        name: 'can make GET request',
+        config: {
+            testRequest: (0, test_config_types_1.initTestRequest)(),
+            expectedResponse: (0, test_config_types_1.initTestResponse)(),
+        },
+    },
+    {
+        name: 'can make POST request with type JSON',
+        config: {
+            testRequest: (0, test_config_types_1.initTestRequest)({
+                method: 'post',
+                bodyType: types_1.DataType.JSON,
+                body: JSON.stringify(postData),
+            }),
+            expectedResponse: (0, test_config_types_1.initTestResponse)(),
+        },
+    },
+    {
+        name: 'can make POST request with type JSON and data is already formatted',
+        config: {
+            testRequest: (0, test_config_types_1.initTestRequest)({
+                method: 'post',
+                bodyType: types_1.DataType.JSON,
+                body: JSON.stringify(JSON.stringify(postData)),
+            }),
+            expectedResponse: (0, test_config_types_1.initTestResponse)(),
+        },
+    },
+    {
+        name: 'can make POST request with zero-length JSON',
+        config: {
+            testRequest: (0, test_config_types_1.initTestRequest)({
+                method: 'post',
+                bodyType: types_1.DataType.JSON,
+                body: JSON.stringify(''),
+            }),
+            expectedResponse: (0, test_config_types_1.initTestResponse)(),
+        },
+    },
+    {
+        name: 'can make POST request with form-data type',
+        config: {
+            testRequest: (0, test_config_types_1.initTestRequest)({
+                method: 'post',
+                bodyType: types_1.DataType.URLEncoded,
+                body: JSON.stringify(postData),
+            }),
+            expectedResponse: (0, test_config_types_1.initTestResponse)(),
+        },
+    },
+    {
+        name: 'can make POST request with form-data type and data is already formatted',
+        config: {
+            testRequest: (0, test_config_types_1.initTestRequest)({
+                method: 'post',
+                bodyType: types_1.DataType.URLEncoded,
+                body: processed_query_1.default.stringify(postData),
+            }),
+            expectedResponse: (0, test_config_types_1.initTestResponse)(),
+        },
+    },
+    {
+        name: 'can make POST request with GraphQL type',
+        config: {
+            testRequest: (0, test_config_types_1.initTestRequest)({
+                method: 'post',
+                bodyType: types_1.DataType.GraphQL,
+                body: graphqlQuery,
+            }),
+            expectedResponse: (0, test_config_types_1.initTestResponse)(),
+        },
+    },
+    {
+        name: 'can make PUT request with type JSON',
+        config: {
+            testRequest: (0, test_config_types_1.initTestRequest)({
+                method: 'put',
+                url: '/url/path/123',
+                bodyType: types_1.DataType.JSON,
+                body: JSON.stringify(putData),
+            }),
+            expectedResponse: (0, test_config_types_1.initTestResponse)(),
+        },
+    },
+    {
+        name: 'can make DELETE request',
+        config: {
+            testRequest: (0, test_config_types_1.initTestRequest)({
+                method: 'delete',
+                url: '/url/path/123',
+            }),
+            expectedResponse: (0, test_config_types_1.initTestResponse)(),
+        },
+    },
+    {
+        name: 'gracefully handles 403 error',
+        config: {
+            testRequest: (0, test_config_types_1.initTestRequest)({ url: '/url/path/403' }),
+            expectedResponse: (0, test_config_types_1.initTestResponse)({
+                statusCode: 403,
+                statusText: 'Did not work',
+                errorType: 'HttpResponseError',
+                expectRequestId: 'Request id header',
+            }),
+        },
+    },
+    {
+        name: 'gracefully handles 404 error',
+        config: {
+            testRequest: (0, test_config_types_1.initTestRequest)({ url: '/url/path/404' }),
+            expectedResponse: (0, test_config_types_1.initTestResponse)({
+                statusCode: 404,
+                statusText: 'Did not work',
+                errorType: 'HttpResponseError',
+            }),
+        },
+    },
+    {
+        name: 'gracefully handles 429 error',
+        config: {
+            testRequest: (0, test_config_types_1.initTestRequest)({ url: '/url/path/429' }),
+            expectedResponse: (0, test_config_types_1.initTestResponse)({
+                statusCode: 429,
+                statusText: 'Did not work',
+                errorType: 'HttpThrottlingError',
+                expectRequestId: 'Request id header',
+            }),
+        },
+    },
+    {
+        name: 'gracefully handles 500 error',
+        config: {
+            testRequest: (0, test_config_types_1.initTestRequest)({ url: '/url/path/500' }),
+            expectedResponse: (0, test_config_types_1.initTestResponse)({
+                statusCode: 500,
+                statusText: 'Did not work',
+                errorType: 'HttpInternalError',
+                expectRequestId: 'Request id header',
+            }),
+        },
+    },
+    {
+        name: 'allows custom headers',
+        config: {
+            testRequest: (0, test_config_types_1.initTestRequest)({
+                url: '/url/path/custom',
+                headers: { 'X-Not-A-Real-Header': 'some_value' },
+            }),
+            expectedResponse: (0, test_config_types_1.initTestResponse)({
+                headers: { 'X-Not-A-Real-Header': 'some_value' },
+            }),
+        },
+    },
+    {
+        name: 'extends User-Agent if it is provided (capitalized)',
+        config: {
+            testRequest: (0, test_config_types_1.initTestRequest)({
+                url: '/url/path/uppercaseua',
+                headers: { 'User-Agent': 'My agent' },
+            }),
+            expectedResponse: (0, test_config_types_1.initTestResponse)({
+                headers: { 'User-Agent': 'My agent' },
+            }),
+        },
+    },
+    {
+        name: 'extends User-Agent if it is provided (lowercase)',
+        config: {
+            testRequest: (0, test_config_types_1.initTestRequest)({
+                url: '/url/path/lowercaseua',
+                headers: { 'user-agent': 'My lowercase agent' },
+            }),
+            expectedResponse: (0, test_config_types_1.initTestResponse)({
+                headers: { 'user-agent': 'My lowercase agent' },
+            }),
+        },
+    },
+    {
+        name: 'fails with invalid retry count',
+        config: {
+            testRequest: (0, test_config_types_1.initTestRequest)({ tries: -1 }),
+            expectedResponse: (0, test_config_types_1.initTestResponse)({
+                statusCode: 500,
+                statusText: 'Did not work',
+                errorType: 'HttpRequestError',
+            }),
+        },
+    },
+    {
+        name: 'retries failed requests but returns success',
+        config: {
+            testRequest: (0, test_config_types_1.initTestRequest)({
+                url: '/url/path/retries',
+                tries: 3,
+                retryTimeoutTimer: 0,
+            }),
+            expectedResponse: (0, test_config_types_1.initTestResponse)(),
+        },
+    },
+    {
+        name: 'retries failed requests and stops on non-retriable errors',
+        config: {
+            testRequest: (0, test_config_types_1.initTestRequest)({
+                url: '/url/path/retrythenfail',
+                tries: 3,
+                retryTimeoutTimer: 0,
+            }),
+            expectedResponse: (0, test_config_types_1.initTestResponse)({
+                statusCode: 403,
+                statusText: 'Did not work',
+                errorType: 'HttpResponseError',
+            }),
+        },
+    },
+    {
+        name: 'stops retrying after reaching the limit',
+        config: {
+            testRequest: (0, test_config_types_1.initTestRequest)({
+                url: '/url/path/maxretries',
+                tries: 3,
+                retryTimeoutTimer: 0,
+            }),
+            expectedResponse: (0, test_config_types_1.initTestResponse)({
+                statusCode: 500,
+                statusText: 'Did not work',
+                errorType: 'HttpMaxRetriesError',
+            }),
+        },
+    },
+    {
+        name: 'waits for the amount of time defined by the Retry-After header',
+        config: {
+            testRequest: (0, test_config_types_1.initTestRequest)({
+                url: '/url/path/retrythensuccess',
+                tries: 2,
+                retryTimeoutTimer: 3000,
+            }),
+            expectedResponse: (0, test_config_types_1.initTestResponse)(),
+        },
+    },
+    {
+        name: 'properly encodes strings in the error message',
+        config: {
+            testRequest: (0, test_config_types_1.initTestRequest)({
+                url: '/url/path/error',
+                retryTimeoutTimer: 0,
+            }),
+            expectedResponse: (0, test_config_types_1.initTestResponse)({
+                statusCode: 500,
+                statusText: 'Did not work',
+                errorType: 'HttpInternalError',
+                errorMessage: "Shopify internal error:\n\"Something went wrong\"",
+            }),
+        },
+    },
+    {
+        name: 'properly encodes objects in the error message',
+        config: {
+            testRequest: (0, test_config_types_1.initTestRequest)({
+                url: '/url/path/detailederror',
+                retryTimeoutTimer: 0,
+            }),
+            expectedResponse: (0, test_config_types_1.initTestResponse)({
+                statusCode: 500,
+                statusText: 'Did not work',
+                errorType: 'HttpInternalError',
+                errorMessage: "Shopify internal error:" +
+                    "\n{" +
+                    "\n  \"title\": \"Invalid title\"," +
+                    "\n  \"description\": \"Invalid description\"" +
+                    "\n}",
+            }),
+        },
+    },
+    {
+        name: 'adds missing slashes to paths',
+        config: {
+            testRequest: (0, test_config_types_1.initTestRequest)({ url: 'url/path' }),
+            expectedResponse: (0, test_config_types_1.initTestResponse)(),
+        },
+    },
+    {
+        name: 'properly formats arrays and hashes in query strings',
+        config: {
+            testRequest: (0, test_config_types_1.initTestRequest)({
+                url: '/url/path/query',
+                query: JSON.stringify({
+                    array: ['a', 'b', 'c'],
+                    // eslint-disable-next-line id-length
+                    hash: { a: 'b', c: 'd' },
+                }),
+            }),
+            expectedResponse: (0, test_config_types_1.initTestResponse)(),
+        },
+    },
+];

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

@@ -0,0 +1,5 @@
+import { Headers } from '../../runtime/http';
+import { ConfigInterface } from '../../base-types';
+export declare function matchHeaders(received: Headers, expected: Headers): boolean;
+export declare const config: ConfigInterface;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/adapters/__e2etests__/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,OAAO,EAAsB,MAAM,oBAAoB,CAAC;AAEhE,OAAO,EAAC,eAAe,EAAqB,MAAM,kBAAkB,CAAC;AAGrE,wBAAgB,YAAY,CAAC,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,GAAG,OAAO,CAkB1E;AAED,eAAO,MAAM,MAAM,EAAE,eAUpB,CAAC"}

package/dist/adapters/__e2etests__/utils.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = exports.matchHeaders = void 0;
+var tslib_1 = require("tslib");
+var http_1 = require("../../runtime/http");
+var memory_1 = require("../../session-storage/memory");
+var base_types_1 = require("../../base-types");
+var scopes_1 = require("../../auth/scopes");
+function matchHeaders(received, expected) {
+    var e_1, _a;
+    var expectedHeadersCorrect = true;
+    var canonicalizedReceived = (0, http_1.canonicalizeHeaders)(received);
+    var canonicalizedExpected = (0, http_1.canonicalizeHeaders)(expected);
+    if (Object.keys(canonicalizedExpected).length > 0) {
+        try {
+            for (var _b = tslib_1.__values(Object.entries(canonicalizedExpected)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = tslib_1.__read(_c.value, 2), expectedKey = _d[0], expectedValues = _d[1];
+                expectedHeadersCorrect =
+                    expectedHeadersCorrect &&
+                        expectedKey in canonicalizedReceived &&
+                        received[expectedKey][0].includes(expectedValues[0]);
+                if (!expectedHeadersCorrect)
+                    return false;
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    }
+    return expectedHeadersCorrect;
+}
+exports.matchHeaders = matchHeaders;
+exports.config = {
+    apiKey: 'test_key',
+    apiSecretKey: 'test_secret_key',
+    scopes: new scopes_1.AuthScopes('test_scope'),
+    hostName: 'test_host_name',
+    hostScheme: 'https',
+    apiVersion: base_types_1.LATEST_API_VERSION,
+    isEmbeddedApp: true,
+    isPrivateApp: false,
+    sessionStorage: new memory_1.MemorySessionStorage(),
+};

package/dist/adapters/cf-worker/adapter.d.ts

@@ -0,0 +1,13 @@
+import { AdapterArgs, NormalizedRequest, NormalizedResponse, Headers } from '../../runtime/http';
+interface WorkerAdapterArgs extends AdapterArgs {
+    rawRequest: Request;
+}
+declare type WorkerHeaders = [string, string][];
+export declare function workerConvertRequest(adapterArgs: WorkerAdapterArgs): Promise<NormalizedRequest>;
+export declare function workerConvertResponse(resp: NormalizedResponse, adapterArgs: WorkerAdapterArgs): Promise<Response>;
+export declare function workerConvertHeaders(headers: Headers, _adapterArgs: WorkerAdapterArgs): Promise<WorkerHeaders>;
+export declare function workerFetch({ url, method, headers, body, }: NormalizedRequest): Promise<NormalizedResponse>;
+export declare function workerCreateDefaultStorage(): never;
+export declare function workerRuntimeString(): string;
+export {};
+//# sourceMappingURL=adapter.d.ts.map

package/dist/adapters/cf-worker/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../../src/adapters/cf-worker/adapter.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,WAAW,EACX,iBAAiB,EACjB,kBAAkB,EAClB,OAAO,EAER,MAAM,oBAAoB,CAAC;AAE5B,UAAU,iBAAkB,SAAQ,WAAW;IAC7C,UAAU,EAAE,OAAO,CAAC;CACrB;AAED,aAAK,aAAa,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC;AAExC,wBAAsB,oBAAoB,CACxC,WAAW,EAAE,iBAAiB,GAC7B,OAAO,CAAC,iBAAiB,CAAC,CAW5B;AAED,wBAAsB,qBAAqB,CACzC,IAAI,EAAE,kBAAkB,EACxB,WAAW,EAAE,iBAAiB,GAC7B,OAAO,CAAC,QAAQ,CAAC,CAMnB;AAED,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,OAAO,EAChB,YAAY,EAAE,iBAAiB,GAC9B,OAAO,CAAC,aAAa,CAAC,CAExB;AAED,wBAAsB,WAAW,CAAC,EAChC,GAAG,EACH,MAAM,EACN,OAAY,EACZ,IAAI,GACL,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CASjD;AAED,wBAAgB,0BAA0B,IAAI,KAAK,CAIlD;AAED,wBAAgB,mBAAmB,IAAI,MAAM,CAE5C"}

package/dist/adapters/cf-worker/adapter.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workerRuntimeString = exports.workerCreateDefaultStorage = exports.workerFetch = exports.workerConvertHeaders = exports.workerConvertResponse = exports.workerConvertRequest = void 0;
+var tslib_1 = require("tslib");
+var error_1 = require("../../error");
+var http_1 = require("../../runtime/http");
+function workerConvertRequest(adapterArgs) {
+    var _a;
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var request, headers, _b, _c, _d, key, value;
+        var e_1, _e;
+        return tslib_1.__generator(this, function (_f) {
+            request = adapterArgs.rawRequest;
+            headers = {};
+            try {
+                for (_b = tslib_1.__values(request.headers.entries()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    _d = tslib_1.__read(_c.value, 2), key = _d[0], value = _d[1];
+                    (0, http_1.addHeader)(headers, key, value);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_e = _b.return)) _e.call(_b);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            return [2 /*return*/, {
+                    headers: headers,
+                    method: (_a = request.method) !== null && _a !== void 0 ? _a : 'GET',
+                    url: request.url,
+                }];
+        });
+    });
+}
+exports.workerConvertRequest = workerConvertRequest;
+function workerConvertResponse(resp, adapterArgs) {
+    var _a;
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var _b, _c;
+        var _d;
+        return tslib_1.__generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    _b = Response.bind;
+                    _c = [void 0, resp.body];
+                    _d = {
+                        status: resp.statusCode,
+                        statusText: resp.statusText
+                    };
+                    return [4 /*yield*/, workerConvertHeaders((_a = resp.headers) !== null && _a !== void 0 ? _a : {}, adapterArgs)];
+                case 1: return [2 /*return*/, new (_b.apply(Response, _c.concat([(_d.headers = _e.sent(),
+                            _d)])))()];
+            }
+        });
+    });
+}
+exports.workerConvertResponse = workerConvertResponse;
+function workerConvertHeaders(headers, _adapterArgs) {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        return tslib_1.__generator(this, function (_a) {
+            return [2 /*return*/, Promise.resolve((0, http_1.flatHeaders)(headers !== null && headers !== void 0 ? headers : {}))];
+        });
+    });
+}
+exports.workerConvertHeaders = workerConvertHeaders;
+function workerFetch(_a) {
+    var url = _a.url, method = _a.method, _b = _a.headers, headers = _b === void 0 ? {} : _b, body = _a.body;
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var resp, respBody;
+        return tslib_1.__generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, fetch(url, { method: method, headers: (0, http_1.flatHeaders)(headers), body: body })];
+                case 1:
+                    resp = _c.sent();
+                    return [4 /*yield*/, resp.text()];
+                case 2:
+                    respBody = _c.sent();
+                    return [2 /*return*/, {
+                            statusCode: resp.status,
+                            statusText: resp.statusText,
+                            body: respBody,
+                            headers: (0, http_1.canonicalizeHeaders)(Object.fromEntries(resp.headers.entries())),
+                        }];
+            }
+        });
+    });
+}
+exports.workerFetch = workerFetch;
+function workerCreateDefaultStorage() {
+    throw new error_1.ShopifyError('You must specify a session storage implementation for CloudFlare workers');
+}
+exports.workerCreateDefaultStorage = workerCreateDefaultStorage;
+function workerRuntimeString() {
+    return 'Cloudflare worker';
+}
+exports.workerRuntimeString = workerRuntimeString;

package/dist/adapters/cf-worker/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/adapters/cf-worker/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/adapters/cf-worker/index.ts"],"names":[],"mappings":""}

package/dist/adapters/cf-worker/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var runtime_1 = require("../../runtime");
+var adapter_1 = require("./adapter");
+(0, runtime_1.setAbstractFetchFunc)(adapter_1.workerFetch);
+(0, runtime_1.setAbstractConvertRequestFunc)(adapter_1.workerConvertRequest);
+(0, runtime_1.setAbstractConvertResponseFunc)(adapter_1.workerConvertResponse);
+(0, runtime_1.setAbstractConvertHeadersFunc)(adapter_1.workerConvertHeaders);
+(0, runtime_1.setAbstractCreateDefaultStorage)(adapter_1.workerCreateDefaultStorage);
+(0, runtime_1.setAbstractRuntimeString)(adapter_1.workerRuntimeString);
+(0, runtime_1.setCrypto)(crypto);

package/dist/adapters/mock/adapter.d.ts

@@ -0,0 +1,13 @@
+import { MemorySessionStorage } from '../../session-storage/memory';
+import { AdapterArgs, AdapterHeaders, Headers, NormalizedRequest, NormalizedResponse } from '../../runtime/http';
+interface MockAdapterArgs extends AdapterArgs {
+    rawRequest: NormalizedRequest;
+}
+export declare function mockConvertRequest(adapterArgs: MockAdapterArgs): Promise<NormalizedRequest>;
+export declare function mockConvertResponse(response: NormalizedResponse, _adapterArgs: MockAdapterArgs): Promise<NormalizedResponse>;
+export declare function mockConvertHeaders(headers: Headers, _adapterArgs: MockAdapterArgs): Promise<AdapterHeaders>;
+export declare function mockFetch({ url, method, headers, body, }: NormalizedRequest): Promise<NormalizedResponse>;
+export declare function mockCreateDefaultStorage(): MemorySessionStorage;
+export declare function mockRuntimeString(): string;
+export {};
+//# sourceMappingURL=adapter.d.ts.map

package/dist/adapters/mock/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../../src/adapters/mock/adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,oBAAoB,EAAC,MAAM,8BAA8B,CAAC;AAClE,OAAO,EACL,WAAW,EACX,cAAc,EAEd,OAAO,EACP,iBAAiB,EACjB,kBAAkB,EACnB,MAAM,oBAAoB,CAAC;AAI5B,UAAU,eAAgB,SAAQ,WAAW;IAC3C,UAAU,EAAE,iBAAiB,CAAC;CAC/B;AAED,wBAAsB,kBAAkB,CACtC,WAAW,EAAE,eAAe,GAC3B,OAAO,CAAC,iBAAiB,CAAC,CAE5B;AAED,wBAAsB,mBAAmB,CACvC,QAAQ,EAAE,kBAAkB,EAC5B,YAAY,EAAE,eAAe,GAC5B,OAAO,CAAC,kBAAkB,CAAC,CAE7B;AAED,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,OAAO,EAChB,YAAY,EAAE,eAAe,GAC5B,OAAO,CAAC,cAAc,CAAC,CAEzB;AAED,wBAAsB,SAAS,CAAC,EAC9B,GAAG,EACH,MAAM,EACN,OAAY,EACZ,IAAI,GACL,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAajD;AAED,wBAAgB,wBAAwB,yBAEvC;AAED,wBAAgB,iBAAiB,WAEhC"}

package/dist/adapters/mock/adapter.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mockRuntimeString = exports.mockCreateDefaultStorage = exports.mockFetch = exports.mockConvertHeaders = exports.mockConvertResponse = exports.mockConvertRequest = void 0;
+var tslib_1 = require("tslib");
+var memory_1 = require("../../session-storage/memory");
+var http_1 = require("../../runtime/http");
+var mock_test_requests_1 = require("./mock_test_requests");
+function mockConvertRequest(adapterArgs) {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        return tslib_1.__generator(this, function (_a) {
+            return [2 /*return*/, Promise.resolve(adapterArgs.rawRequest)];
+        });
+    });
+}
+exports.mockConvertRequest = mockConvertRequest;
+function mockConvertResponse(response, _adapterArgs) {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        return tslib_1.__generator(this, function (_a) {
+            return [2 /*return*/, Promise.resolve(response)];
+        });
+    });
+}
+exports.mockConvertResponse = mockConvertResponse;
+function mockConvertHeaders(headers, _adapterArgs) {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        return tslib_1.__generator(this, function (_a) {
+            return [2 /*return*/, Promise.resolve(headers)];
+        });
+    });
+}
+exports.mockConvertHeaders = mockConvertHeaders;
+function mockFetch(_a) {
+    var url = _a.url, method = _a.method, _b = _a.headers, headers = _b === void 0 ? {} : _b, body = _a.body;
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var next;
+        return tslib_1.__generator(this, function (_c) {
+            mock_test_requests_1.mockTestRequests.requestList.push({
+                url: url,
+                method: method,
+                headers: (0, http_1.canonicalizeHeaders)(headers),
+                body: body,
+            });
+            next = mock_test_requests_1.mockTestRequests.responseList.shift();
+            if (next instanceof Error) {
+                throw next;
+            }
+            return [2 /*return*/, next];
+        });
+    });
+}
+exports.mockFetch = mockFetch;
+function mockCreateDefaultStorage() {
+    return new memory_1.MemorySessionStorage();
+}
+exports.mockCreateDefaultStorage = mockCreateDefaultStorage;
+function mockRuntimeString() {
+    return 'Mock adapter';
+}
+exports.mockRuntimeString = mockRuntimeString;

package/dist/adapters/mock/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/adapters/mock/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/adapters/mock/index.ts"],"names":[],"mappings":""}

package/dist/adapters/mock/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var crypto_1 = tslib_1.__importDefault(require("crypto"));
+var runtime_1 = require("../../runtime");
+var adapter_1 = require("./adapter");
+(0, runtime_1.setAbstractFetchFunc)(adapter_1.mockFetch);
+(0, runtime_1.setAbstractConvertRequestFunc)(adapter_1.mockConvertRequest);
+(0, runtime_1.setAbstractConvertResponseFunc)(adapter_1.mockConvertResponse);
+(0, runtime_1.setAbstractConvertHeadersFunc)(adapter_1.mockConvertHeaders);
+(0, runtime_1.setAbstractCreateDefaultStorage)(adapter_1.mockCreateDefaultStorage);
+(0, runtime_1.setAbstractRuntimeString)(adapter_1.mockRuntimeString);
+(0, runtime_1.setCrypto)(crypto_1.default);

package/dist/adapters/mock/mock_test_requests.d.ts

@@ -0,0 +1,15 @@
+import { NormalizedRequest, NormalizedResponse } from '../../runtime/http';
+declare type RequestListEntry = NormalizedRequest;
+declare type ResponseListEntry = NormalizedResponse | Error;
+interface MockedAdapter {
+    requestList: RequestListEntry[];
+    responseList: ResponseListEntry[];
+    queueResponse: (response: NormalizedResponse) => void;
+    queueError: (error: Error) => void;
+    getRequest: () => RequestListEntry | undefined;
+    getResponses: () => ResponseListEntry[];
+    reset: () => void;
+}
+export declare const mockTestRequests: MockedAdapter;
+export {};
+//# sourceMappingURL=mock_test_requests.d.ts.map

package/dist/adapters/mock/mock_test_requests.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock_test_requests.d.ts","sourceRoot":"","sources":["../../../src/adapters/mock/mock_test_requests.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,iBAAiB,EAAE,kBAAkB,EAAC,MAAM,oBAAoB,CAAC;AAEzE,aAAK,gBAAgB,GAAG,iBAAiB,CAAC;AAC1C,aAAK,iBAAiB,GAAG,kBAAkB,GAAG,KAAK,CAAC;AAEpD,UAAU,aAAa;IACrB,WAAW,EAAE,gBAAgB,EAAE,CAAC;IAChC,YAAY,EAAE,iBAAiB,EAAE,CAAC;IAClC,aAAa,EAAE,CAAC,QAAQ,EAAE,kBAAkB,KAAK,IAAI,CAAC;IACtD,UAAU,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACnC,UAAU,EAAE,MAAM,gBAAgB,GAAG,SAAS,CAAC;IAC/C,YAAY,EAAE,MAAM,iBAAiB,EAAE,CAAC;IACxC,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB;AAED,eAAO,MAAM,gBAAgB,EAAE,aAwB9B,CAAC"}

package/dist/adapters/mock/mock_test_requests.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mockTestRequests = void 0;
+exports.mockTestRequests = {
+    requestList: [],
+    responseList: [],
+    queueResponse: function (response) {
+        this.responseList.push(response);
+    },
+    queueError: function (error) {
+        this.responseList.push(error);
+    },
+    getRequest: function () {
+        return this.requestList.shift();
+    },
+    getResponses: function () {
+        return this.responseList;
+    },
+    reset: function () {
+        this.requestList = [];
+        this.responseList = [];
+    },
+};