@aws-amplify/core 6.0.1-preview-testing.be90020.0 → 6.0.1-ssr-api.df60e41.0

package/lib-esm/ServiceWorker/ServiceWorker.js

@@ -1,23 +1,11 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-/**
- * Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
- * the License. A copy of the License is located at
- *
- *     http://aws.amazon.com/apache2.0/
- *
- * or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
- * CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
- * and limitations under the License.
- */
 import { ConsoleLogger as Logger } from '../Logger';
-import { isBrowser } from '../Util/JS';
-import { Amplify } from '../Amplify';
-import { asserts } from '../Util/errors/AssertError';
-import { AmplifyError } from '../Util/Errors';
-import { SERVICE_WORKER_EXCEPTION } from '../Util/Constants';
+import { isBrowser } from '../utils';
+import { AmplifyError } from '../errors';
+import { assert, ServiceWorkerErrorCode } from './errorHelpers';
+import { record } from '../providers/pinpoint';
+import { Amplify, fetchAuthSession } from '../singleton';
 /**
  * Provides a means to registering a service worker in the browser
  * and communicating with it via postMessage events.
@@ -30,25 +18,18 @@ import { SERVICE_WORKER_EXCEPTION } from '../Util/Constants';
  * and attempt to dispatch messages on state change and record analytics
  * events based on the service worker lifecycle.
  */
-var ServiceWorkerClass = /** @class */ (function () {
-    function ServiceWorkerClass() {
+export class ServiceWorkerClass {
+    constructor() {
         // The AWS Amplify logger
         this._logger = new Logger('ServiceWorker');
     }
-    Object.defineProperty(ServiceWorkerClass.prototype, "serviceWorker", {
-        /**
-         * Get the currently active service worker
-         */
-        get: function () {
-            asserts(this._serviceWorker !== undefined, {
-                name: SERVICE_WORKER_EXCEPTION,
-                message: 'Service Worker instance is undefined',
-            });
-            return this._serviceWorker;
-        },
-        enumerable: false,
-        configurable: true
-    });
+    /**
+     * Get the currently active service worker
+     */
+    get serviceWorker() {
+        assert(this._serviceWorker !== undefined, ServiceWorkerErrorCode.UndefinedInstance);
+        return this._serviceWorker;
+    }
     /**
      * Register the service-worker.js file in the browser
      * Make sure the service-worker.js is part of the build
@@ -61,37 +42,34 @@ var ServiceWorkerClass = /** @class */ (function () {
      *	- resolve(ServiceWorkerRegistration)
      *	- reject(Error)
      **/
-    ServiceWorkerClass.prototype.register = function (filePath, scope) {
-        var _this = this;
-        if (filePath === void 0) { filePath = '/service-worker.js'; }
-        if (scope === void 0) { scope = '/'; }
-        this._logger.debug("registering ".concat(filePath));
-        this._logger.debug("registering service worker with scope ".concat(scope));
-        return new Promise(function (resolve, reject) {
+    register(filePath = '/service-worker.js', scope = '/') {
+        this._logger.debug(`registering ${filePath}`);
+        this._logger.debug(`registering service worker with scope ${scope}`);
+        return new Promise((resolve, reject) => {
             if (navigator && 'serviceWorker' in navigator) {
                 navigator.serviceWorker
                     .register(filePath, {
-                    scope: scope,
+                    scope,
                 })
-                    .then(function (registration) {
+                    .then(registration => {
                     if (registration.installing) {
-                        _this._serviceWorker = registration.installing;
+                        this._serviceWorker = registration.installing;
                     }
                     else if (registration.waiting) {
-                        _this._serviceWorker = registration.waiting;
+                        this._serviceWorker = registration.waiting;
                     }
                     else if (registration.active) {
-                        _this._serviceWorker = registration.active;
+                        this._serviceWorker = registration.active;
                     }
-                    _this._registration = registration;
-                    _this._setupListeners();
-                    _this._logger.debug("Service Worker Registration Success: ".concat(registration));
+                    this._registration = registration;
+                    this._setupListeners();
+                    this._logger.debug(`Service Worker Registration Success: ${registration}`);
                     return resolve(registration);
                 })
-                    .catch(function (error) {
-                    _this._logger.debug("Service Worker Registration Failed ".concat(error));
+                    .catch(error => {
+                    this._logger.debug(`Service Worker Registration Failed ${error}`);
                     return reject(new AmplifyError({
-                        name: SERVICE_WORKER_EXCEPTION,
+                        name: ServiceWorkerErrorCode.Unavailable,
                         message: 'Service Worker not available',
                         underlyingError: error,
                     }));
@@ -99,12 +77,12 @@ var ServiceWorkerClass = /** @class */ (function () {
             }
             else {
                 return reject(new AmplifyError({
-                    name: SERVICE_WORKER_EXCEPTION,
+                    name: ServiceWorkerErrorCode.Unavailable,
                     message: 'Service Worker not available',
                 }));
             }
         });
-    };
+    }
     /**
      * Enable web push notifications. If not subscribed, a new subscription will
      * be created and registered.
@@ -116,66 +94,59 @@ var ServiceWorkerClass = /** @class */ (function () {
      * 	- resolve(PushSubscription)
      *  - reject(Error)
      */
-    ServiceWorkerClass.prototype.enablePush = function (publicKey) {
-        var _this = this;
-        asserts(this._registration !== undefined, {
-            name: SERVICE_WORKER_EXCEPTION,
-            message: 'Service Worker registration is undefined',
-        });
+    enablePush(publicKey) {
+        assert(this._registration !== undefined, ServiceWorkerErrorCode.UndefinedRegistration);
         this._publicKey = publicKey;
-        return new Promise(function (resolve, reject) {
+        return new Promise((resolve, reject) => {
             if (isBrowser()) {
-                asserts(_this._registration !== undefined, {
-                    name: SERVICE_WORKER_EXCEPTION,
-                    message: 'Service Worker registration is undefined',
-                });
-                _this._registration.pushManager.getSubscription().then(function (subscription) {
+                assert(this._registration !== undefined, ServiceWorkerErrorCode.UndefinedRegistration);
+                this._registration.pushManager.getSubscription().then(subscription => {
                     if (subscription) {
-                        _this._subscription = subscription;
-                        _this._logger.debug("User is subscribed to push: ".concat(JSON.stringify(subscription)));
+                        this._subscription = subscription;
+                        this._logger.debug(`User is subscribed to push: ${JSON.stringify(subscription)}`);
                         resolve(subscription);
                     }
                     else {
-                        _this._logger.debug("User is NOT subscribed to push");
-                        return _this._registration.pushManager.subscribe({
+                        this._logger.debug(`User is NOT subscribed to push`);
+                        return this._registration.pushManager.subscribe({
                             userVisibleOnly: true,
-                            applicationServerKey: _this._urlB64ToUint8Array(publicKey),
+                            applicationServerKey: this._urlB64ToUint8Array(publicKey),
                         })
-                            .then(function (subscription) {
-                            _this._subscription = subscription;
-                            _this._logger.debug("User subscribed: ".concat(JSON.stringify(subscription)));
+                            .then(subscription => {
+                            this._subscription = subscription;
+                            this._logger.debug(`User subscribed: ${JSON.stringify(subscription)}`);
                             resolve(subscription);
                         })
-                            .catch(function (error) {
-                            _this._logger.error(error);
+                            .catch(error => {
+                            this._logger.error(error);
                         });
                     }
                 });
             }
             else {
                 return reject(new AmplifyError({
-                    name: SERVICE_WORKER_EXCEPTION,
+                    name: ServiceWorkerErrorCode.Unavailable,
                     message: 'Service Worker not available',
                 }));
             }
         });
-    };
+    }
     /**
      * Convert a base64 encoded string to a Uint8 array for the push server key
      * @param base64String
      */
-    ServiceWorkerClass.prototype._urlB64ToUint8Array = function (base64String) {
-        var padding = '='.repeat((4 - (base64String.length % 4)) % 4);
-        var base64 = (base64String + padding)
+    _urlB64ToUint8Array(base64String) {
+        const padding = '='.repeat((4 - (base64String.length % 4)) % 4);
+        const base64 = (base64String + padding)
             .replace(/\-/g, '+')
             .replace(/_/g, '/');
-        var rawData = window.atob(base64);
-        var outputArray = new Uint8Array(rawData.length);
-        for (var i = 0; i < rawData.length; ++i) {
+        const rawData = window.atob(base64);
+        const outputArray = new Uint8Array(rawData.length);
+        for (let i = 0; i < rawData.length; ++i) {
             outputArray[i] = rawData.charCodeAt(i);
         }
         return outputArray;
-    };
+    }
     /**
      * Send a message to the service worker. The service worker needs
      * to implement `self.addEventListener('message') to handle the
@@ -184,37 +155,39 @@ var ServiceWorkerClass = /** @class */ (function () {
      *	- see: https://developer.mozilla.org/en-US/docs/Web/API/Transferable
      * @returns {Promise}
      **/
-    ServiceWorkerClass.prototype.send = function (message) {
+    send(message) {
         if (this._serviceWorker) {
             this._serviceWorker.postMessage(typeof message === 'object' ? JSON.stringify(message) : message);
         }
-    };
+    }
     /**
      * Listen for service worker state change and message events
      * https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/state
      **/
-    ServiceWorkerClass.prototype._setupListeners = function () {
-        var _this = this;
-        this.serviceWorker.addEventListener('statechange', function (event) {
-            var currentState = _this.serviceWorker.state;
-            _this._logger.debug("ServiceWorker statechange: ".concat(currentState));
-            Amplify.Analytics;
-            if (isAmplifyWithAnalytics(Amplify)) {
-                Amplify.Analytics.record({
-                    name: 'ServiceWorker',
-                    attributes: {
-                        state: currentState,
+    _setupListeners() {
+        this.serviceWorker.addEventListener('statechange', async (event) => {
+            const currentState = this.serviceWorker.state;
+            this._logger.debug(`ServiceWorker statechange: ${currentState}`);
+            const { appId, region } = Amplify.getConfig().Analytics?.Pinpoint ?? {};
+            const { credentials } = await fetchAuthSession();
+            if (appId && region && credentials) {
+                // Pinpoint is configured, record an event
+                record({
+                    appId,
+                    region,
+                    category: 'Core',
+                    credentials,
+                    event: {
+                        name: 'ServiceWorker',
+                        attributes: {
+                            state: currentState,
+                        },
                     },
                 });
             }
         });
-        this.serviceWorker.addEventListener('message', function (event) {
-            _this._logger.debug("ServiceWorker message event: ".concat(event));
+        this.serviceWorker.addEventListener('message', event => {
+            this._logger.debug(`ServiceWorker message event: ${event}`);
         });
-    };
-    return ServiceWorkerClass;
-}());
-export { ServiceWorkerClass };
-function isAmplifyWithAnalytics(amplify) {
-    return amplify.Analytics && typeof amplify.Analytics.record === 'function';
+    }
 }

package/lib-esm/ServiceWorker/errorHelpers.d.ts

@@ -0,0 +1,7 @@
+import { AssertionFunction } from '../types';
+export declare enum ServiceWorkerErrorCode {
+    UndefinedInstance = "UndefinedInstance",
+    UndefinedRegistration = "UndefinedRegistration",
+    Unavailable = "Unavailable"
+}
+export declare const assert: AssertionFunction<ServiceWorkerErrorCode>;

package/lib-esm/ServiceWorker/errorHelpers.js

@@ -0,0 +1,21 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { createAssertionFunction } from '../errors';
+export var ServiceWorkerErrorCode;
+(function (ServiceWorkerErrorCode) {
+    ServiceWorkerErrorCode["UndefinedInstance"] = "UndefinedInstance";
+    ServiceWorkerErrorCode["UndefinedRegistration"] = "UndefinedRegistration";
+    ServiceWorkerErrorCode["Unavailable"] = "Unavailable";
+})(ServiceWorkerErrorCode || (ServiceWorkerErrorCode = {}));
+const serviceWorkerErrorMap = {
+    [ServiceWorkerErrorCode.UndefinedInstance]: {
+        message: 'Service Worker instance is undefined.',
+    },
+    [ServiceWorkerErrorCode.UndefinedRegistration]: {
+        message: 'Service Worker registration is undefined.',
+    },
+    [ServiceWorkerErrorCode.Unavailable]: {
+        message: 'Service Worker not available.',
+    },
+};
+export const assert = createAssertionFunction(serviceWorkerErrorMap);

package/lib-esm/ServiceWorker/index.d.ts

@@ -1,13 +1 @@
-/**
- * Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
- * the License. A copy of the License is located at
- *
- *     http://aws.amazon.com/apache2.0/
- *
- * or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
- * CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
- * and limitations under the License.
- */
 export { ServiceWorkerClass as ServiceWorker } from './ServiceWorker';

package/lib-esm/ServiceWorker/index.js

@@ -1,15 +1,3 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-/**
- * Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
- * the License. A copy of the License is located at
- *
- *     http://aws.amazon.com/apache2.0/
- *
- * or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
- * CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
- * and limitations under the License.
- */
 export { ServiceWorkerClass as ServiceWorker } from './ServiceWorker';

package/lib-esm/{Util → Signer}/DateUtils.js

@@ -6,30 +6,14 @@
  *
  * @see https://github.com/aws/aws-sdk-js/blob/6edf586dcc1de7fe8fbfbbd9a0d2b1847921e6e1/lib/util.js#L262
  */
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
 // Comment - TODO: remove
-var FIVE_MINUTES_IN_MS = 1000 * 60 * 5;
-export var DateUtils = {
+const FIVE_MINUTES_IN_MS = 1000 * 60 * 5;
+export const DateUtils = {
     /**
      * Milliseconds to offset the date to compensate for clock skew between device & services
      */
     clockOffset: 0,
-    getDateWithClockOffset: function () {
+    getDateWithClockOffset() {
         if (DateUtils.clockOffset) {
             return new Date(new Date().getTime() + DateUtils.clockOffset);
         }
@@ -40,33 +24,32 @@ export var DateUtils = {
     /**
      * @returns {number} Clock offset in milliseconds
      */
-    getClockOffset: function () {
+    getClockOffset() {
         return DateUtils.clockOffset;
     },
-    getHeaderStringFromDate: function (date) {
-        if (date === void 0) { date = DateUtils.getDateWithClockOffset(); }
+    getHeaderStringFromDate(date = DateUtils.getDateWithClockOffset()) {
         return date.toISOString().replace(/[:\-]|\.\d{3}/g, '');
     },
-    getDateFromHeaderString: function (header) {
-        var _a = __read(header.match(/^(\d{4})(\d{2})(\d{2})T(\d{2})(\d{2})(\d{2}).+/), 7), year = _a[1], month = _a[2], day = _a[3], hour = _a[4], minute = _a[5], second = _a[6];
+    getDateFromHeaderString(header) {
+        const [, year, month, day, hour, minute, second] = header.match(/^(\d{4})(\d{2})(\d{2})T(\d{2})(\d{2})(\d{2}).+/);
         return new Date(Date.UTC(Number(year), Number(month) - 1, Number(day), Number(hour), Number(minute), Number(second)));
     },
-    isClockSkewed: function (serverDate) {
+    isClockSkewed(serverDate) {
         // API gateway permits client calls that are off by no more than ±5 minutes
         return (Math.abs(serverDate.getTime() - DateUtils.getDateWithClockOffset().getTime()) >= FIVE_MINUTES_IN_MS);
     },
-    isClockSkewError: function (error) {
+    isClockSkewError(error) {
         if (!error.response || !error.response.headers) {
             return false;
         }
-        var headers = error.response.headers;
+        const { headers } = error.response;
         return Boolean(['BadRequestException', 'InvalidSignatureException'].includes(headers['x-amzn-errortype']) &&
             (headers.date || headers.Date));
     },
     /**
      * @param {number} offset Clock offset in milliseconds
      */
-    setClockOffset: function (offset) {
+    setClockOffset(offset) {
         DateUtils.clockOffset = offset;
     },
 };

package/lib-esm/Signer/Signer.js

@@ -0,0 +1,124 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { DateUtils } from './DateUtils';
+import { presignUrl, signRequest, TOKEN_QUERY_PARAM, } from '../clients/middleware/signing/signer/signatureV4';
+import { AmplifyUrl } from '../utils/amplifyUrl';
+const IOT_SERVICE_NAME = 'iotdevicegateway';
+// Best practice regex to parse the service and region from an AWS endpoint
+const AWS_ENDPOINT_REGEX = /([^\.]+)\.(?:([^\.]*)\.)?amazonaws\.com(.cn)?$/;
+export class Signer {
+    /**
+    * Sign a HTTP request, add 'Authorization' header to request param
+    * @method sign
+    * @memberof Signer
+    * @static
+    *
+    * @param {object} request - HTTP request object
+    <pre>
+    request: {
+        method: GET | POST | PUT ...
+        url: ...,
+        headers: {
+            header1: ...
+        },
+        data: data
+    }
+    </pre>
+    * @param {object} access_info - AWS access credential info
+    <pre>
+    access_info: {
+        access_key: ...,
+        secret_key: ...,
+        session_token: ...
+    }
+    </pre>
+    * @param {object} [service_info] - AWS service type and region, optional,
+    *                                  if not provided then parse out from url
+    <pre>
+    service_info: {
+        service: ...,
+        region: ...
+    }
+    </pre>
+    *
+    * @returns {object} Signed HTTP request
+    */
+    static sign(request, accessInfo, serviceInfo) {
+        request.headers = request.headers || {};
+        if (request.body && !request.data) {
+            throw new Error('The attribute "body" was found on the request object. Please use the attribute "data" instead.');
+        }
+        const requestToSign = {
+            ...request,
+            body: request.data,
+            url: new AmplifyUrl(request.url),
+        };
+        const options = getOptions(requestToSign, accessInfo, serviceInfo);
+        const signedRequest = signRequest(requestToSign, options);
+        // Prior to using `signRequest`, Signer accepted urls as strings and outputted urls as string. Coerce the property
+        // back to a string so as not to disrupt consumers of Signer.
+        signedRequest.url = signedRequest.url.toString();
+        // HTTP headers should be case insensitive but, to maintain parity with the previous Signer implementation and
+        // limit the impact of this implementation swap, replace lowercased headers with title cased ones.
+        signedRequest.headers.Authorization = signedRequest.headers.authorization;
+        signedRequest.headers['X-Amz-Security-Token'] =
+            signedRequest.headers['x-amz-security-token'];
+        delete signedRequest.headers.authorization;
+        delete signedRequest.headers['x-amz-security-token'];
+        return signedRequest;
+    }
+    static signUrl(urlOrRequest, accessInfo, serviceInfo, expiration) {
+        const urlToSign = typeof urlOrRequest === 'object' ? urlOrRequest.url : urlOrRequest;
+        const method = typeof urlOrRequest === 'object' ? urlOrRequest.method : 'GET';
+        const body = typeof urlOrRequest === 'object' ? urlOrRequest.body : undefined;
+        const presignable = {
+            body,
+            method,
+            url: new AmplifyUrl(urlToSign),
+        };
+        const options = getOptions(presignable, accessInfo, serviceInfo, expiration);
+        const signedUrl = presignUrl(presignable, options);
+        if (accessInfo.session_token &&
+            !sessionTokenRequiredInSigning(options.signingService)) {
+            signedUrl.searchParams.append(TOKEN_QUERY_PARAM, accessInfo.session_token);
+        }
+        return signedUrl.toString();
+    }
+}
+const getOptions = (request, accessInfo, serviceInfo, expiration) => {
+    const { access_key, secret_key, session_token } = accessInfo ?? {};
+    const { region: urlRegion, service: urlService } = parseServiceInfo(request.url);
+    const { region = urlRegion, service = urlService } = serviceInfo ?? {};
+    const credentials = {
+        accessKeyId: access_key,
+        secretAccessKey: secret_key,
+        ...(sessionTokenRequiredInSigning(service)
+            ? { sessionToken: session_token }
+            : {}),
+    };
+    return {
+        credentials,
+        signingDate: DateUtils.getDateWithClockOffset(),
+        signingRegion: region,
+        signingService: service,
+        ...(expiration && { expiration }),
+    };
+};
+// TODO: V6 investigate whether add to custom clients' general signer implementation.
+const parseServiceInfo = (url) => {
+    const host = url.host;
+    const matched = host.match(AWS_ENDPOINT_REGEX) ?? [];
+    let parsed = matched.slice(1, 3);
+    if (parsed[1] === 'es') {
+        // Elastic Search
+        parsed = parsed.reverse();
+    }
+    return {
+        service: parsed[0],
+        region: parsed[1],
+    };
+};
+// IoT service does not allow the session token in the canonical request
+// https://docs.aws.amazon.com/general/latest/gr/sigv4-add-signature-to-request.html
+// TODO: V6 investigate whether add to custom clients' general signer implementation.
+const sessionTokenRequiredInSigning = (service) => service !== IOT_SERVICE_NAME;

package/lib-esm/Signer/index.d.ts

@@ -0,0 +1 @@
+export { Signer } from './Signer';

package/lib-esm/Signer/index.js

@@ -0,0 +1,3 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+export { Signer } from './Signer';

package/lib-esm/adapterCore/error/AmplifyServerContextError.d.ts

@@ -1,4 +1,4 @@
-import { AmplifyError } from '../../libraryUtils';
+import { AmplifyError } from '../../errors';
 export declare class AmplifyServerContextError extends AmplifyError {
     constructor({ message, recoverySuggestion, underlyingError, }: {
         message: string;

package/lib-esm/adapterCore/error/AmplifyServerContextError.js

@@ -1,32 +1,13 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-import { AmplifyError } from '../../libraryUtils';
-var AmplifyServerContextError = /** @class */ (function (_super) {
-    __extends(AmplifyServerContextError, _super);
-    function AmplifyServerContextError(_a) {
-        var message = _a.message, recoverySuggestion = _a.recoverySuggestion, underlyingError = _a.underlyingError;
-        return _super.call(this, {
+import { AmplifyError } from '../../errors';
+export class AmplifyServerContextError extends AmplifyError {
+    constructor({ message, recoverySuggestion, underlyingError, }) {
+        super({
             name: 'AmplifyServerContextError',
-            message: message,
-            recoverySuggestion: recoverySuggestion,
-            underlyingError: underlyingError,
-        }) || this;
+            message,
+            recoverySuggestion,
+            underlyingError,
+        });
     }
-    return AmplifyServerContextError;
-}(AmplifyError));
-export { AmplifyServerContextError };
+}

package/lib-esm/adapterCore/serverContext/serverContext.js

@@ -8,11 +8,11 @@ import { AmplifyClass } from '../../singleton';
  * @param libraryOptions The Amplify library options.
  * @returns The Amplify server context spec.
  */
-export var createAmplifyServerContext = function (amplifyConfig, libraryOptions) {
-    var amplify = new AmplifyClass();
+export const createAmplifyServerContext = (amplifyConfig, libraryOptions) => {
+    const amplify = new AmplifyClass();
     amplify.configure(amplifyConfig, libraryOptions);
     return serverContextRegistry.register({
-        amplify: amplify,
+        amplify,
     });
 };
 /**
@@ -20,8 +20,8 @@ export var createAmplifyServerContext = function (amplifyConfig, libraryOptions)
  * @param contextSpec The context spec used to get the Amplify server context.
  * @returns The Amplify server context.
  */
-export var getAmplifyServerContext = function (contextSpec) {
-    var context = serverContextRegistry.get(contextSpec);
+export const getAmplifyServerContext = (contextSpec) => {
+    const context = serverContextRegistry.get(contextSpec);
     if (context) {
         return context;
     }
@@ -31,6 +31,6 @@ export var getAmplifyServerContext = function (contextSpec) {
  * Destroys an Amplify server context.
  * @param contextSpec The context spec used to destroy the Amplify server context.
  */
-export var destroyAmplifyServerContext = function (contextSpec) {
+export const destroyAmplifyServerContext = (contextSpec) => {
     serverContextRegistry.deregister(contextSpec);
 };