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

package/dist/adapters/__e2etests__/test_config_types.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initTestResponse = exports.initTestRequest = void 0;
+var tslib_1 = require("tslib");
+function initTestRequest(options) {
+    var defaults = {
+        method: 'get',
+        url: '/url/path',
+        headers: {},
+    };
+    return tslib_1.__assign(tslib_1.__assign({}, defaults), options);
+}
+exports.initTestRequest = initTestRequest;
+function initTestResponse(options) {
+    var defaults = {
+        statusCode: 200,
+        statusText: 'OK',
+        headers: {},
+        body: JSON.stringify({ message: 'Your HTTP request was successful!' }),
+    };
+    return tslib_1.__assign(tslib_1.__assign({}, defaults), options);
+}
+exports.initTestResponse = initTestResponse;

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

@@ -0,0 +1,4 @@
+import { E2eTestEnvironment } from './test_config_types';
+export declare function shutdownEnvironments(environments: E2eTestEnvironment[]): void;
+export declare function runEnvironments(environments: E2eTestEnvironment[]): Promise<boolean>;
+//# sourceMappingURL=test_environments.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"test_environments.d.ts","sourceRoot":"","sources":["../../../src/adapters/__e2etests__/test_environments.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,kBAAkB,EAAC,MAAM,qBAAqB,CAAC;AAQvD,wBAAgB,oBAAoB,CAAC,YAAY,EAAE,kBAAkB,EAAE,GAAG,IAAI,CAM7E;AAeD,wBAAsB,eAAe,CACnC,YAAY,EAAE,kBAAkB,EAAE,GACjC,OAAO,CAAC,OAAO,CAAC,CAiBlB"}

package/dist/adapters/__e2etests__/test_environments.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runEnvironments = exports.shutdownEnvironments = void 0;
+var tslib_1 = require("tslib");
+var node_fetch_1 = tslib_1.__importDefault(require("node-fetch"));
+function sleep(ms) {
+    return new Promise(function (resolve) {
+        setTimeout(resolve, ms);
+    });
+}
+function shutdownEnvironments(environments) {
+    var e_1, _a;
+    try {
+        for (var environments_1 = tslib_1.__values(environments), environments_1_1 = environments_1.next(); !environments_1_1.done; environments_1_1 = environments_1.next()) {
+            var env = environments_1_1.value;
+            if (typeof env.process.pid !== 'undefined') {
+                process.kill(-env.process.pid);
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (environments_1_1 && !environments_1_1.done && (_a = environments_1.return)) _a.call(environments_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+}
+exports.shutdownEnvironments = shutdownEnvironments;
+function serverReady(domain) {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var response, err_1;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 2, , 3]);
+                    return [4 /*yield*/, (0, node_fetch_1.default)(domain)];
+                case 1:
+                    response = _a.sent();
+                    return [2 /*return*/, response.status === 200];
+                case 2:
+                    err_1 = _a.sent();
+                    return [2 /*return*/, false];
+                case 3: return [2 /*return*/];
+            }
+        });
+    });
+}
+function allEnvironmentsReady(environments) {
+    return environments.map(function (env) { return env.ready; }).every(function (ready) { return ready; });
+}
+function runEnvironments(environments) {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var maxAttempts, environments_2, environments_2_1, env, attempts, ready, e_2_1;
+        var e_2, _a;
+        return tslib_1.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    maxAttempts = 5;
+                    if (allEnvironmentsReady(environments))
+                        return [2 /*return*/, true];
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 9, 10, 11]);
+                    environments_2 = tslib_1.__values(environments), environments_2_1 = environments_2.next();
+                    _b.label = 2;
+                case 2:
+                    if (!!environments_2_1.done) return [3 /*break*/, 8];
+                    env = environments_2_1.value;
+                    attempts = 0;
+                    ready = false;
+                    _b.label = 3;
+                case 3:
+                    if (!(!ready && attempts < maxAttempts)) return [3 /*break*/, 6];
+                    attempts++;
+                    return [4 /*yield*/, sleep(100)];
+                case 4:
+                    _b.sent();
+                    return [4 /*yield*/, serverReady(env.domain)];
+                case 5:
+                    ready = _b.sent();
+                    return [3 /*break*/, 3];
+                case 6:
+                    env.ready = ready;
+                    _b.label = 7;
+                case 7:
+                    environments_2_1 = environments_2.next();
+                    return [3 /*break*/, 2];
+                case 8: return [3 /*break*/, 11];
+                case 9:
+                    e_2_1 = _b.sent();
+                    e_2 = { error: e_2_1 };
+                    return [3 /*break*/, 11];
+                case 10:
+                    try {
+                        if (environments_2_1 && !environments_2_1.done && (_a = environments_2.return)) _a.call(environments_2);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                    return [7 /*endfinally*/];
+                case 11: return [2 /*return*/, allEnvironmentsReady(environments)];
+            }
+        });
+    });
+}
+exports.runEnvironments = runEnvironments;

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

@@ -0,0 +1,8 @@
+export declare const testSuite: {
+    name: string;
+    config: {
+        testRequest: import("./test_config_types").TestRequest;
+        expectedResponse: import("./test_config_types").TestResponse;
+    };
+}[];
+//# sourceMappingURL=test_suite.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"test_suite.d.ts","sourceRoot":"","sources":["../../../src/adapters/__e2etests__/test_suite.ts"],"names":[],"mappings":"AA4BA,eAAO,MAAM,SAAS;;;;;;GA0SrB,CAAC"}

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/index.js

@@ -1,14 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var http_1 = require("../../runtime/http");
-var crypto_1 = require("../../runtime/crypto");
-var session_1 = require("../../runtime/session");
-var platform_1 = require("../../runtime/platform");
+var runtime_1 = require("../../runtime");
 var adapter_1 = require("./adapter");
-(0, http_1.setAbstractFetchFunc)(adapter_1.workerFetch);
-(0, http_1.setAbstractConvertRequestFunc)(adapter_1.workerConvertRequest);
-(0, http_1.setAbstractConvertResponseFunc)(adapter_1.workerConvertResponse);
-(0, http_1.setAbstractConvertHeadersFunc)(adapter_1.workerConvertHeaders);
-(0, session_1.setAbstractCreateDefaultStorage)(adapter_1.workerCreateDefaultStorage);
-(0, platform_1.setAbstractRuntimeString)(adapter_1.workerRuntimeString);
-(0, crypto_1.setCrypto)(crypto);
+(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/index.js

@@ -2,15 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 var tslib_1 = require("tslib");
 var crypto_1 = tslib_1.__importDefault(require("crypto"));
-var http_1 = require("../../runtime/http");
-var crypto_2 = require("../../runtime/crypto");
-var session_1 = require("../../runtime/session");
-var platform_1 = require("../../runtime/platform");
+var runtime_1 = require("../../runtime");
 var adapter_1 = require("./adapter");
-(0, http_1.setAbstractFetchFunc)(adapter_1.mockFetch);
-(0, http_1.setAbstractConvertRequestFunc)(adapter_1.mockConvertRequest);
-(0, http_1.setAbstractConvertResponseFunc)(adapter_1.mockConvertResponse);
-(0, http_1.setAbstractConvertHeadersFunc)(adapter_1.mockConvertHeaders);
-(0, session_1.setAbstractCreateDefaultStorage)(adapter_1.mockCreateDefaultStorage);
-(0, platform_1.setAbstractRuntimeString)(adapter_1.mockRuntimeString);
-(0, crypto_2.setCrypto)(crypto_1.default);
+(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/node/index.js

@@ -2,15 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 var tslib_1 = require("tslib");
 var crypto_1 = tslib_1.__importDefault(require("crypto"));
-var http_1 = require("../../runtime/http");
-var crypto_2 = require("../../runtime/crypto");
-var session_1 = require("../../runtime/session");
-var platform_1 = require("../../runtime/platform");
+var runtime_1 = require("../../runtime");
 var adapter_1 = require("./adapter");
-(0, http_1.setAbstractFetchFunc)(adapter_1.nodeFetch);
-(0, http_1.setAbstractConvertRequestFunc)(adapter_1.nodeConvertRequest);
-(0, http_1.setAbstractConvertResponseFunc)(adapter_1.nodeConvertAndSendResponse);
-(0, http_1.setAbstractConvertHeadersFunc)(adapter_1.nodeConvertAndSetHeaders);
-(0, session_1.setAbstractCreateDefaultStorage)(adapter_1.nodeCreateDefaultStorage);
-(0, platform_1.setAbstractRuntimeString)(adapter_1.nodeRuntimeString);
-(0, crypto_2.setCrypto)(crypto_1.default);
+(0, runtime_1.setAbstractFetchFunc)(adapter_1.nodeFetch);
+(0, runtime_1.setAbstractConvertRequestFunc)(adapter_1.nodeConvertRequest);
+(0, runtime_1.setAbstractConvertResponseFunc)(adapter_1.nodeConvertAndSendResponse);
+(0, runtime_1.setAbstractConvertHeadersFunc)(adapter_1.nodeConvertAndSetHeaders);
+(0, runtime_1.setAbstractCreateDefaultStorage)(adapter_1.nodeCreateDefaultStorage);
+(0, runtime_1.setAbstractRuntimeString)(adapter_1.nodeRuntimeString);
+(0, runtime_1.setCrypto)(crypto_1.default);

package/dist/auth/oauth/oauth.d.ts

@@ -1,8 +1,6 @@
 import { ConfigInterface } from '../../base-types';
 import { AdapterResponse } from '../../runtime/http';
 import { BeginParams, CallbackParams, CallbackResponse } from './types';
-export declare const SESSION_COOKIE_NAME = "shopify_app_session";
-export declare const STATE_COOKIE_NAME = "shopify_app_state";
 export declare function createBegin(config: ConfigInterface): ({ shop, callbackPath, isOnline, ...adapterArgs }: BeginParams) => Promise<AdapterResponse>;
 export declare function createCallback(config: ConfigInterface): <T = any>({ isOnline, ...adapterArgs }: CallbackParams) => Promise<CallbackResponse<T>>;
 //# sourceMappingURL=oauth.d.ts.map

package/dist/auth/oauth/oauth.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"oauth.d.ts","sourceRoot":"","sources":["../../../src/auth/oauth/oauth.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,eAAe,EAAC,MAAM,kBAAkB,CAAC;AAYjD,OAAO,EAIL,eAAe,EAIhB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EACL,WAAW,EACX,cAAc,EAKd,gBAAgB,EACjB,MAAM,SAAS,CAAC;AAIjB,eAAO,MAAM,mBAAmB,wBAAwB,CAAC;AACzD,eAAO,MAAM,iBAAiB,sBAAsB,CAAC;AAErD,wBAAgB,WAAW,CAAC,MAAM,EAAE,eAAe,sDAM9C,WAAW,KAAG,QAAQ,eAAe,CAAC,CA6C1C;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,eAAe,2CAIjD,cAAc,kCAiFlB"}
+{"version":3,"file":"oauth.d.ts","sourceRoot":"","sources":["../../../src/auth/oauth/oauth.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,eAAe,EAAC,MAAM,kBAAkB,CAAC;AAYjD,OAAO,EAIL,eAAe,EAIhB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAGL,WAAW,EACX,cAAc,EAKd,gBAAgB,EACjB,MAAM,SAAS,CAAC;AAIjB,wBAAgB,WAAW,CAAC,MAAM,EAAE,eAAe,sDAM9C,WAAW,KAAG,QAAQ,eAAe,CAAC,CA6C1C;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,eAAe,2CAIjD,cAAc,kCAiFlB"}

package/dist/auth/oauth/oauth.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createCallback = exports.createBegin = exports.STATE_COOKIE_NAME = exports.SESSION_COOKIE_NAME = void 0;
+exports.createCallback = exports.createBegin = void 0;
 var tslib_1 = require("tslib");
 var uuid_1 = require("uuid");
 var processed_query_1 = tslib_1.__importDefault(require("../../utils/processed-query"));
@@ -12,10 +12,9 @@ var session_utils_1 = require("../../session/session-utils");
 var http_client_1 = require("../../clients/http_client/http_client");
 var types_1 = require("../../clients/http_client/types");
 var http_1 = require("../../runtime/http");
+var types_2 = require("./types");
 var nonce_1 = require("./nonce");
 var safe_compare_1 = require("./safe-compare");
-exports.SESSION_COOKIE_NAME = 'shopify_app_session';
-exports.STATE_COOKIE_NAME = 'shopify_app_state';
 function createBegin(config) {
     var _this = this;
     return function (_a) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
@@ -34,7 +33,7 @@ function createBegin(config) {
                         secure: true,
                     });
                     state = (0, nonce_1.nonce)();
-                    return [4 /*yield*/, cookies.setAndSign(exports.STATE_COOKIE_NAME, state, {
+                    return [4 /*yield*/, cookies.setAndSign(types_2.STATE_COOKIE_NAME, state, {
                             expires: new Date(Date.now() + 60000),
                             sameSite: 'lax',
                             secure: true,
@@ -79,10 +78,10 @@ function createCallback(config) {
                             keys: [config.apiSecretKey],
                             secure: true,
                         });
-                        return [4 /*yield*/, cookies.getAndVerify(exports.STATE_COOKIE_NAME)];
+                        return [4 /*yield*/, cookies.getAndVerify(types_2.STATE_COOKIE_NAME)];
                     case 2:
                         stateFromCookie = _c.sent();
-                        cookies.deleteCookie(exports.STATE_COOKIE_NAME);
+                        cookies.deleteCookie(types_2.STATE_COOKIE_NAME);
                         if (!stateFromCookie) {
                             throw new ShopifyErrors.CookieNotFound("Cannot complete OAuth process. Could not find an OAuth cookie for shop url: ".concat(query.get('shop')));
                         }
@@ -116,7 +115,7 @@ function createCallback(config) {
                             config: config,
                         });
                         if (!!config.isEmbeddedApp) return [3 /*break*/, 6];
-                        return [4 /*yield*/, cookies.setAndSign(exports.SESSION_COOKIE_NAME, session.id, {
+                        return [4 /*yield*/, cookies.setAndSign(types_2.SESSION_COOKIE_NAME, session.id, {
                                 expires: session.expires,
                                 sameSite: 'lax',
                                 secure: true,