@ama-sdk/core 10.3.0-prerelease.9 → 10.4.0-prerelease.0

package/esm2015/plugins/pii-tokenizer/pii-tokenizer.spec.js

@@ -174,43 +174,43 @@ function _ts_generator(thisArg, body) {
         };
     }
 }
-import * as jsonToken from "../../utils/json-token";
-import { PiiTokenizerRequest } from "./pii-tokenizer.request";
-describe("Tokenizer Request Plugin", function() {
+import * as jsonToken from '../../utils/json-token';
+import { PiiTokenizerRequest } from './pii-tokenizer.request';
+describe('Tokenizer Request Plugin', function() {
     var options;
     var tokenizedOptions = {
-        url: "http://test.com/path/$pathParamToken$",
+        url: 'http://test.com/path/$pathParamToken$',
         queryParams: {
-            classicParam: "classicParamValue",
-            sensitiveParam: "$sensitiveParamToken$"
+            classicParam: 'classicParamValue',
+            sensitiveParam: '$sensitiveParamToken$'
         },
         values: {
-            $pathParamToken$: "pathParamValue",
-            $sensitiveParamToken$: "sensitiveParamValue"
+            $pathParamToken$: 'pathParamValue',
+            $sensitiveParamToken$: 'sensitiveParamValue'
         }
     };
     beforeEach(function() {
         options = {
-            method: "get",
+            method: 'get',
             headers: new Headers(),
-            basePath: "http://test.com/path/pathParamValue",
+            basePath: 'http://test.com/path/pathParamValue',
             queryParams: {
-                classicParam: "classicParamValue",
-                sensitiveParam: "sensitiveParamValue"
+                classicParam: 'classicParamValue',
+                sensitiveParam: 'sensitiveParamValue'
             }
         };
-        jest.spyOn(console, "error");
+        jest.spyOn(console, 'error');
     });
     afterEach(function() {
         jest.restoreAllMocks();
     });
-    it("should replace sensitive parameters with tokens", /*#__PURE__*/ _async_to_generator(function() {
+    it('should replace sensitive parameters with tokens', /*#__PURE__*/ _async_to_generator(function() {
         var plugin, runner, result;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
                     plugin = new PiiTokenizerRequest({
-                        applicationId: "app-id"
+                        applicationId: 'app-id'
                     });
                     runner = plugin.load();
                     return [
@@ -221,24 +221,24 @@ describe("Tokenizer Request Plugin", function() {
                     ];
                 case 1:
                     result = _state.sent();
-                    expect(result.basePath).toEqual("http://test.com/path/$pathParamToken$");
-                    expect(result.queryParams.classicParam).toEqual("classicParamValue");
-                    expect(result.queryParams.sensitiveParam).toEqual("$sensitiveParamToken$");
-                    expect(result.headers.get("ama-client-facts")).not.toBeNull();
+                    expect(result.basePath).toEqual('http://test.com/path/$pathParamToken$');
+                    expect(result.queryParams.classicParam).toEqual('classicParamValue');
+                    expect(result.queryParams.sensitiveParam).toEqual('$sensitiveParamToken$');
+                    expect(result.headers.get('ama-client-facts')).not.toBeNull();
                     return [
                         2
                     ];
             }
         });
     }));
-    it("should put token-value associations in custom header if provided", /*#__PURE__*/ _async_to_generator(function() {
+    it('should put token-value associations in custom header if provided', /*#__PURE__*/ _async_to_generator(function() {
         var plugin, runner, result;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
                     plugin = new PiiTokenizerRequest({
-                        applicationId: "app-id",
-                        headerName: "custom-header"
+                        applicationId: 'app-id',
+                        headerName: 'custom-header'
                     });
                     runner = plugin.load();
                     return [
@@ -249,21 +249,21 @@ describe("Tokenizer Request Plugin", function() {
                     ];
                 case 1:
                     result = _state.sent();
-                    expect(result.headers.get("ama-client-facts")).toBeNull();
-                    expect(result.headers.get("custom-header")).not.toBeNull();
+                    expect(result.headers.get('ama-client-facts')).toBeNull();
+                    expect(result.headers.get('custom-header')).not.toBeNull();
                     return [
                         2
                     ];
             }
         });
     }));
-    it("should keep default parameters and print an error if tokenization is disabled", /*#__PURE__*/ _async_to_generator(function() {
+    it('should keep default parameters and print an error if tokenization is disabled', /*#__PURE__*/ _async_to_generator(function() {
         var plugin, runner, result;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
                     plugin = new PiiTokenizerRequest({
-                        applicationId: "app-id"
+                        applicationId: 'app-id'
                     });
                     runner = plugin.load();
                     return [
@@ -272,10 +272,10 @@ describe("Tokenizer Request Plugin", function() {
                     ];
                 case 1:
                     result = _state.sent();
-                    expect(result.basePath).toEqual("http://test.com/path/pathParamValue");
-                    expect(result.queryParams.classicParam).toEqual("classicParamValue");
-                    expect(result.queryParams.sensitiveParam).toEqual("sensitiveParamValue");
-                    expect(result.headers.get("ama-client-facts")).toBeNull();
+                    expect(result.basePath).toEqual('http://test.com/path/pathParamValue');
+                    expect(result.queryParams.classicParam).toEqual('classicParamValue');
+                    expect(result.queryParams.sensitiveParam).toEqual('sensitiveParamValue');
+                    expect(result.headers.get('ama-client-facts')).toBeNull();
                     // eslint-disable-next-line no-console
                     expect(console.error).toHaveBeenCalled();
                     return [
@@ -284,13 +284,13 @@ describe("Tokenizer Request Plugin", function() {
             }
         });
     }));
-    it("should keep default parameters if no token-value associations is provided", /*#__PURE__*/ _async_to_generator(function() {
+    it('should keep default parameters if no token-value associations is provided', /*#__PURE__*/ _async_to_generator(function() {
         var plugin, runner, result;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
                     plugin = new PiiTokenizerRequest({
-                        applicationId: "app-id"
+                        applicationId: 'app-id'
                     });
                     runner = plugin.load();
                     return [
@@ -303,10 +303,10 @@ describe("Tokenizer Request Plugin", function() {
                     ];
                 case 1:
                     result = _state.sent();
-                    expect(result.basePath).toEqual("http://test.com/path/pathParamValue");
-                    expect(result.queryParams.classicParam).toEqual("classicParamValue");
-                    expect(result.queryParams.sensitiveParam).toEqual("sensitiveParamValue");
-                    expect(result.headers.get("ama-client-facts")).toBeNull();
+                    expect(result.basePath).toEqual('http://test.com/path/pathParamValue');
+                    expect(result.queryParams.classicParam).toEqual('classicParamValue');
+                    expect(result.queryParams.sensitiveParam).toEqual('sensitiveParamValue');
+                    expect(result.headers.get('ama-client-facts')).toBeNull();
                     // eslint-disable-next-line no-console
                     expect(console.error).not.toHaveBeenCalled();
                     return [
@@ -315,15 +315,15 @@ describe("Tokenizer Request Plugin", function() {
             }
         });
     }));
-    it("should use JWT if no key specified", /*#__PURE__*/ _async_to_generator(function() {
+    it('should use JWT if no key specified', /*#__PURE__*/ _async_to_generator(function() {
         var mockJweEncoder, mockJwtEncoder, plugin, runner;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
-                    mockJweEncoder = jest.spyOn(jsonToken, "createJweEncoder");
-                    mockJwtEncoder = jest.spyOn(jsonToken, "createJwtEncoder");
+                    mockJweEncoder = jest.spyOn(jsonToken, 'createJweEncoder');
+                    mockJwtEncoder = jest.spyOn(jsonToken, 'createJwtEncoder');
                     plugin = new PiiTokenizerRequest({
-                        applicationId: "app-id"
+                        applicationId: 'app-id'
                     });
                     runner = plugin.load();
                     return [
@@ -342,25 +342,25 @@ describe("Tokenizer Request Plugin", function() {
             }
         });
     }));
-    it("should use JWE if a key is specified", /*#__PURE__*/ _async_to_generator(function() {
+    it('should use JWE if a key is specified', /*#__PURE__*/ _async_to_generator(function() {
         var key, mockJweEncoder, mockJwtEncoder, plugin, runner, result, expectedJwePayload;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
-                    jest.spyOn(Date, "now").mockImplementation(function() {
+                    jest.spyOn(Date, 'now').mockImplementation(function() {
                         return 0;
                     });
                     key = {
-                        publicKey: "myPublicKey",
-                        keyId: "TEST"
+                        publicKey: 'myPublicKey',
+                        keyId: 'TEST'
                     };
-                    mockJweEncoder = jest.fn().mockResolvedValue("myJweToken");
-                    jest.spyOn(jsonToken, "createJweEncoder").mockImplementation(function() {
+                    mockJweEncoder = jest.fn().mockResolvedValue('myJweToken');
+                    jest.spyOn(jsonToken, 'createJweEncoder').mockImplementation(function() {
                         return mockJweEncoder;
                     });
-                    mockJwtEncoder = jest.spyOn(jsonToken, "createJwtEncoder");
+                    mockJwtEncoder = jest.spyOn(jsonToken, 'createJwtEncoder');
                     plugin = new PiiTokenizerRequest({
-                        applicationId: "app-id",
+                        applicationId: 'app-id',
                         key: key
                     });
                     runner = plugin.load();
@@ -374,19 +374,19 @@ describe("Tokenizer Request Plugin", function() {
                     result = _state.sent();
                     expectedJwePayload = {
                         // eslint-disable-next-line @typescript-eslint/naming-convention
-                        "ama-tokens": {
-                            $pathParamToken$: "pathParamValue",
-                            $sensitiveParamToken$: "sensitiveParamValue"
+                        'ama-tokens': {
+                            $pathParamToken$: 'pathParamValue',
+                            $sensitiveParamToken$: 'sensitiveParamValue'
                         },
                         exp: 3600,
                         iat: 0,
-                        iss: "app-id",
-                        sub: "pii"
+                        iss: 'app-id',
+                        sub: 'pii'
                     };
-                    expect(result.headers.get("ama-client-facts")).toEqual("myJweToken");
+                    expect(result.headers.get('ama-client-facts')).toEqual('myJweToken');
                     expect(mockJweEncoder).toHaveBeenCalledWith(key, expectedJwePayload, [
-                        "iss",
-                        "sub"
+                        'iss',
+                        'sub'
                     ]);
                     expect(mockJwtEncoder).not.toHaveBeenCalled();
                     return [
@@ -395,21 +395,21 @@ describe("Tokenizer Request Plugin", function() {
             }
         });
     }));
-    it("should throw by default if an exception is raised for JWE encoder", /*#__PURE__*/ _async_to_generator(function() {
+    it('should throw by default if an exception is raised for JWE encoder', /*#__PURE__*/ _async_to_generator(function() {
         var key, mockJweEncoder, plugin, runner;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
                     key = {
-                        publicKey: "myPublicKey",
-                        keyId: "TEST"
+                        publicKey: 'myPublicKey',
+                        keyId: 'TEST'
                     };
-                    mockJweEncoder = jest.fn().mockRejectedValue("Error creating JWE");
-                    jest.spyOn(jsonToken, "createJweEncoder").mockImplementation(function() {
+                    mockJweEncoder = jest.fn().mockRejectedValue('Error creating JWE');
+                    jest.spyOn(jsonToken, 'createJweEncoder').mockImplementation(function() {
                         return mockJweEncoder;
                     });
                     plugin = new PiiTokenizerRequest({
-                        applicationId: "app-id",
+                        applicationId: 'app-id',
                         key: key
                     });
                     runner = plugin.load();
@@ -430,21 +430,21 @@ describe("Tokenizer Request Plugin", function() {
             }
         });
     }));
-    it("should handle errors silently if an exception is raised for JWE encoder", /*#__PURE__*/ _async_to_generator(function() {
+    it('should handle errors silently if an exception is raised for JWE encoder', /*#__PURE__*/ _async_to_generator(function() {
         var key, mockJweEncoder, plugin, runner;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
                     key = {
-                        publicKey: "myPublicKey",
-                        keyId: "TEST"
+                        publicKey: 'myPublicKey',
+                        keyId: 'TEST'
                     };
-                    mockJweEncoder = jest.fn().mockRejectedValue("Error creating JWE");
-                    jest.spyOn(jsonToken, "createJweEncoder").mockImplementation(function() {
+                    mockJweEncoder = jest.fn().mockRejectedValue('Error creating JWE');
+                    jest.spyOn(jsonToken, 'createJweEncoder').mockImplementation(function() {
                         return mockJweEncoder;
                     });
                     plugin = new PiiTokenizerRequest({
-                        applicationId: "app-id",
+                        applicationId: 'app-id',
                         key: key,
                         silent: true
                     });
@@ -466,25 +466,25 @@ describe("Tokenizer Request Plugin", function() {
             }
         });
     }));
-    it("should skip PII tokenization and put DeepLink token in corresponding header when DeepLink token is provided", /*#__PURE__*/ _async_to_generator(function() {
+    it('should skip PII tokenization and put DeepLink token in corresponding header when DeepLink token is provided', /*#__PURE__*/ _async_to_generator(function() {
         var plugin, runner, deepLinkOptions, metadata, result;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
                     plugin = new PiiTokenizerRequest({
-                        applicationId: "app-id"
+                        applicationId: 'app-id'
                     });
                     runner = plugin.load();
                     deepLinkOptions = {
-                        token: "myDeepLinkToken"
+                        token: 'myDeepLinkToken'
                     };
                     metadata = {
                         deepLinkOptions: deepLinkOptions
                     };
-                    options.basePath = "http://test.com/path/$pathParamToken$";
+                    options.basePath = 'http://test.com/path/$pathParamToken$';
                     options.queryParams = {
-                        classicParam: "classicParamValue",
-                        sensitiveParam: "$sensitiveParamToken$"
+                        classicParam: 'classicParamValue',
+                        sensitiveParam: '$sensitiveParamToken$'
                     };
                     return [
                         4,
@@ -497,10 +497,10 @@ describe("Tokenizer Request Plugin", function() {
                     ];
                 case 1:
                     result = _state.sent();
-                    expect(result.basePath).toEqual("http://test.com/path/$pathParamToken$");
-                    expect(result.queryParams.classicParam).toEqual("classicParamValue");
-                    expect(result.queryParams.sensitiveParam).toEqual("$sensitiveParamToken$");
-                    expect(result.headers.get("ama-client-facts")).toEqual("myDeepLinkToken");
+                    expect(result.basePath).toEqual('http://test.com/path/$pathParamToken$');
+                    expect(result.queryParams.classicParam).toEqual('classicParamValue');
+                    expect(result.queryParams.sensitiveParam).toEqual('$sensitiveParamToken$');
+                    expect(result.headers.get('ama-client-facts')).toEqual('myDeepLinkToken');
                     // eslint-disable-next-line no-console
                     expect(console.error).not.toHaveBeenCalled();
                     return [
@@ -509,28 +509,28 @@ describe("Tokenizer Request Plugin", function() {
             }
         });
     }));
-    it("should put DeepLink challenge answers in corresponding header when provided", /*#__PURE__*/ _async_to_generator(function() {
+    it('should put DeepLink challenge answers in corresponding header when provided', /*#__PURE__*/ _async_to_generator(function() {
         var plugin, runner, deepLinkOptions, metadata, result;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
                     plugin = new PiiTokenizerRequest({
-                        applicationId: "app-id"
+                        applicationId: 'app-id'
                     });
                     runner = plugin.load();
                     deepLinkOptions = {
-                        token: "myDeepLinkToken",
+                        token: 'myDeepLinkToken',
                         challengeAnswers: {
-                            lastName: "Doe"
+                            lastName: 'Doe'
                         }
                     };
                     metadata = {
                         deepLinkOptions: deepLinkOptions
                     };
-                    options.basePath = "http://test.com/path/$pathParamToken$";
+                    options.basePath = 'http://test.com/path/$pathParamToken$';
                     options.queryParams = {
-                        classicParam: "classicParamValue",
-                        sensitiveParam: "$sensitiveParamToken$"
+                        classicParam: 'classicParamValue',
+                        sensitiveParam: '$sensitiveParamToken$'
                     };
                     return [
                         4,
@@ -543,29 +543,29 @@ describe("Tokenizer Request Plugin", function() {
                     ];
                 case 1:
                     result = _state.sent();
-                    expect(result.basePath).toEqual("http://test.com/path/$pathParamToken$");
-                    expect(result.queryParams.classicParam).toEqual("classicParamValue");
-                    expect(result.queryParams.sensitiveParam).toEqual("$sensitiveParamToken$");
-                    expect(result.headers.get("ama-client-facts")).toEqual("myDeepLinkToken");
-                    expect(result.headers.get("ama-client-facts-challenge")).toEqual('{"lastName":"Doe"}');
+                    expect(result.basePath).toEqual('http://test.com/path/$pathParamToken$');
+                    expect(result.queryParams.classicParam).toEqual('classicParamValue');
+                    expect(result.queryParams.sensitiveParam).toEqual('$sensitiveParamToken$');
+                    expect(result.headers.get('ama-client-facts')).toEqual('myDeepLinkToken');
+                    expect(result.headers.get('ama-client-facts-challenge')).toEqual('{"lastName":"Doe"}');
                     return [
                         2
                     ];
             }
         });
     }));
-    it("Should not loose additional parameters not expected for the actual request", /*#__PURE__*/ _async_to_generator(function() {
+    it('Should not loose additional parameters not expected for the actual request', /*#__PURE__*/ _async_to_generator(function() {
         var plugin, runner, result;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
                     plugin = new PiiTokenizerRequest({
-                        applicationId: "app-id"
+                        applicationId: 'app-id'
                     });
                     runner = plugin.load();
-                    options.basePath = "http://test.com/path/pathParamValue";
+                    options.basePath = 'http://test.com/path/pathParamValue';
                     options.queryParams = _object_spread_props(_object_spread({}, options.queryParams), {
-                        additionalParam: "foo"
+                        additionalParam: 'foo'
                     });
                     return [
                         4,
@@ -575,8 +575,8 @@ describe("Tokenizer Request Plugin", function() {
                     ];
                 case 1:
                     result = _state.sent();
-                    expect(result.basePath).toEqual("http://test.com/path/$pathParamToken$");
-                    expect(result.queryParams.additionalParam).toEqual("foo");
+                    expect(result.basePath).toEqual('http://test.com/path/$pathParamToken$');
+                    expect(result.queryParams.additionalParam).toEqual('foo');
                     return [
                         2
                     ];

package/esm2015/plugins/raw-response-info/index.js

@@ -1 +1 @@
-export * from "./raw-response-info.reply";
+export * from './raw-response-info.reply';

package/esm2015/plugins/raw-response-info/raw-response-info.spec.js

@@ -122,11 +122,11 @@ function _ts_generator(thisArg, body) {
         };
     }
 }
-import { ApiTypes } from "../../fwk/api";
-import { RawResponseInfoReply } from "./raw-response-info.reply";
-describe("Raw response info Reply plugin", function() {
+import { ApiTypes } from '../../fwk/api';
+import { RawResponseInfoReply } from './raw-response-info.reply';
+describe('Raw response info Reply plugin', function() {
     var reviver = jest.fn();
-    it("should add response object", /*#__PURE__*/ _async_to_generator(function() {
+    it('should add response object', /*#__PURE__*/ _async_to_generator(function() {
         var plugin, runner, data, newData;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
@@ -137,7 +137,7 @@ describe("Raw response info Reply plugin", function() {
                         apiType: ApiTypes.DEFAULT,
                         response: {
                             headers: new Headers(),
-                            test: "OK"
+                            test: 'OK'
                         }
                     });
                     data = {};
@@ -148,14 +148,14 @@ describe("Raw response info Reply plugin", function() {
                 case 1:
                     newData = _state.sent();
                     expect(newData.responseInfo).toBeDefined();
-                    expect(newData.responseInfo.test).toBe("OK");
+                    expect(newData.responseInfo.test).toBe('OK');
                     return [
                         2
                     ];
             }
         });
     }));
-    it("should keep original data", /*#__PURE__*/ _async_to_generator(function() {
+    it('should keep original data', /*#__PURE__*/ _async_to_generator(function() {
         var plugin, runner, data, newData;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
@@ -166,11 +166,11 @@ describe("Raw response info Reply plugin", function() {
                         apiType: ApiTypes.DEFAULT,
                         response: {
                             headers: new Headers(),
-                            test: "OK"
+                            test: 'OK'
                         }
                     });
                     data = {
-                        originalData: "OK"
+                        originalData: 'OK'
                     };
                     return [
                         4,
@@ -178,22 +178,22 @@ describe("Raw response info Reply plugin", function() {
                     ];
                 case 1:
                     newData = _state.sent();
-                    expect(newData.originalData).toBe("OK");
+                    expect(newData.originalData).toBe('OK');
                     return [
                         2
                     ];
             }
         });
     }));
-    it("should invalidate response info", function() {
+    it('should invalidate response info', function() {
         var data = {
-            originalData: "OK"
+            originalData: 'OK'
         };
         expect(RawResponseInfoReply.hasResponseInfo(data)).toBeFalsy();
     });
-    it("should validate response info", function() {
+    it('should validate response info', function() {
         var data = {
-            originalData: "OK",
+            originalData: 'OK',
             responseInfo: {
                 headers: new Headers()
             }

package/esm2015/plugins/retry/index.js

@@ -1 +1 @@
-export * from "./retry.fetch";
+export * from './retry.fetch';

package/esm2015/plugins/retry/retry.fetch.js

@@ -161,7 +161,7 @@ function _ts_generator(thisArg, body) {
         };
     }
 }
-import { CanceledCallError } from "../../fwk/errors";
+import { CanceledCallError } from '../../fwk/errors';
 /**
  * Plugin to Retry a fetch call
  */ export var RetryFetch = /*#__PURE__*/ function() {