@aws-amplify/api-graphql 3.4.12-unstable.7762f1a.0 → 4.0.0

package/lib/utils/ReconnectionMonitor.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../Providers/constants");
+var ReconnectEvent;
+(function (ReconnectEvent) {
+    ReconnectEvent["START_RECONNECT"] = "START_RECONNECT";
+    ReconnectEvent["HALT_RECONNECT"] = "HALT_RECONNECT";
+})(ReconnectEvent = exports.ReconnectEvent || (exports.ReconnectEvent = {}));
+/**
+ * Captures the reconnect event logic used to determine when to reconnect to PubSub providers.
+ *   Reconnnect attempts are delayed by 5 seconds to let the interface settle.
+ *   Attempting to reconnect only once creates unrecoverable states when the network state isn't
+ *   supported by the browser, so this keeps retrying every minute until halted.
+ */
+class ReconnectionMonitor {
+    constructor() {
+        this.reconnectObservers = [];
+    }
+    /**
+     * Add reconnect observer to the list of observers to alert on reconnect
+     */
+    addObserver(reconnectObserver) {
+        this.reconnectObservers.push(reconnectObserver);
+    }
+    /**
+     * Given a reconnect event, start the appropriate behavior
+     */
+    record(event) {
+        if (event === ReconnectEvent.START_RECONNECT) {
+            // If the reconnection hasn't been started
+            if (this.reconnectSetTimeoutId === undefined &&
+                this.reconnectIntervalId === undefined) {
+                this.reconnectSetTimeoutId = setTimeout(() => {
+                    // Reconnect now
+                    this._triggerReconnect();
+                    // Retry reconnect every periodically until it works
+                    this.reconnectIntervalId = setInterval(() => {
+                        this._triggerReconnect();
+                    }, constants_1.RECONNECT_INTERVAL);
+                }, constants_1.RECONNECT_DELAY);
+            }
+        }
+        if (event === ReconnectEvent.HALT_RECONNECT) {
+            if (this.reconnectIntervalId) {
+                clearInterval(this.reconnectIntervalId);
+                this.reconnectIntervalId = undefined;
+            }
+            if (this.reconnectSetTimeoutId) {
+                clearTimeout(this.reconnectSetTimeoutId);
+                this.reconnectSetTimeoutId = undefined;
+            }
+        }
+    }
+    /**
+     * Complete all reconnect observers
+     */
+    close() {
+        this.reconnectObservers.forEach(reconnectObserver => {
+            reconnectObserver.complete?.();
+        });
+    }
+    _triggerReconnect() {
+        this.reconnectObservers.forEach(reconnectObserver => {
+            reconnectObserver.next?.();
+        });
+    }
+}
+exports.ReconnectionMonitor = ReconnectionMonitor;

package/lib/utils/errors/APIError.d.ts

@@ -0,0 +1,7 @@
+import { AmplifyError, AmplifyErrorParams } from '@aws-amplify/core/internals/utils';
+/**
+ * @internal
+ */
+export declare class APIError extends AmplifyError {
+    constructor(params: AmplifyErrorParams);
+}

package/lib/utils/errors/APIError.js

@@ -0,0 +1,18 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@aws-amplify/core/internals/utils");
+/**
+ * @internal
+ */
+class APIError extends utils_1.AmplifyError {
+    constructor(params) {
+        super(params);
+        // Hack for making the custom error class work when transpiled to es5
+        // TODO: Delete the following 2 lines after we change the build target to >= es2015
+        this.constructor = APIError;
+        Object.setPrototypeOf(this, APIError.prototype);
+    }
+}
+exports.APIError = APIError;

package/lib/utils/errors/assertValidationError.d.ts

@@ -0,0 +1,5 @@
+import { APIValidationErrorCode } from './validation';
+/**
+ * @internal
+ */
+export declare function assertValidationError(assertion: boolean, name: APIValidationErrorCode): asserts assertion;

package/lib/utils/errors/assertValidationError.js

@@ -0,0 +1,16 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+const APIError_1 = require("./APIError");
+const validation_1 = require("./validation");
+/**
+ * @internal
+ */
+function assertValidationError(assertion, name) {
+    const { message, recoverySuggestion } = validation_1.validationErrorMap[name];
+    if (!assertion) {
+        throw new APIError_1.APIError({ name, message, recoverySuggestion });
+    }
+}
+exports.assertValidationError = assertValidationError;

package/lib/utils/errors/index.d.ts

@@ -0,0 +1,3 @@
+export { APIError } from './APIError';
+export { assertValidationError } from './assertValidationError';
+export { APIValidationErrorCode, validationErrorMap } from './validation';

package/lib/utils/errors/index.js

@@ -0,0 +1,11 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+var APIError_1 = require("./APIError");
+exports.APIError = APIError_1.APIError;
+var assertValidationError_1 = require("./assertValidationError");
+exports.assertValidationError = assertValidationError_1.assertValidationError;
+var validation_1 = require("./validation");
+exports.APIValidationErrorCode = validation_1.APIValidationErrorCode;
+exports.validationErrorMap = validation_1.validationErrorMap;

package/lib/utils/errors/validation.d.ts

@@ -0,0 +1,7 @@
+import { AmplifyErrorMap } from '@aws-amplify/core/internals/utils';
+export declare enum APIValidationErrorCode {
+    NoAuthSession = "NoAuthSession",
+    NoRegion = "NoRegion",
+    NoCustomEndpoint = "NoCustomEndpoint"
+}
+export declare const validationErrorMap: AmplifyErrorMap<APIValidationErrorCode>;

package/lib/utils/errors/validation.js

@@ -0,0 +1,25 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+var APIValidationErrorCode;
+(function (APIValidationErrorCode) {
+    APIValidationErrorCode["NoAuthSession"] = "NoAuthSession";
+    APIValidationErrorCode["NoRegion"] = "NoRegion";
+    APIValidationErrorCode["NoCustomEndpoint"] = "NoCustomEndpoint";
+})(APIValidationErrorCode = exports.APIValidationErrorCode || (exports.APIValidationErrorCode = {}));
+exports.validationErrorMap = {
+    [APIValidationErrorCode.NoAuthSession]: {
+        message: 'Auth session should not be empty.',
+    },
+    // TODO: re-enable when working in all test environments:
+    // [APIValidationErrorCode.NoEndpoint]: {
+    // 	message: 'Missing endpoint',
+    // },
+    [APIValidationErrorCode.NoRegion]: {
+        message: 'Missing region.',
+    },
+    [APIValidationErrorCode.NoCustomEndpoint]: {
+        message: 'Custom endpoint region is present without custom endpoint.',
+    },
+};

package/lib/utils/index.d.ts

@@ -0,0 +1,2 @@
+export { resolveConfig } from './resolveConfig';
+export { resolveLibraryOptions } from './resolveLibraryOptions';

package/lib/utils/index.js

@@ -0,0 +1,8 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+var resolveConfig_1 = require("./resolveConfig");
+exports.resolveConfig = resolveConfig_1.resolveConfig;
+var resolveLibraryOptions_1 = require("./resolveLibraryOptions");
+exports.resolveLibraryOptions = resolveLibraryOptions_1.resolveLibraryOptions;

package/lib/utils/resolveConfig.d.ts

@@ -0,0 +1,12 @@
+import { AmplifyClassV6 } from '@aws-amplify/core';
+/**
+ * @internal
+ */
+export declare const resolveConfig: (amplify: AmplifyClassV6) => {
+    apiKey: string | undefined;
+    customEndpoint: string | undefined;
+    customEndpointRegion: string | undefined;
+    defaultAuthMode: "apiKey" | "oidc" | "userPool" | "iam" | "lambda" | "none" | undefined;
+    endpoint: string | undefined;
+    region: string | undefined;
+};

package/lib/utils/resolveConfig.js

@@ -0,0 +1,22 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_1 = require("./errors");
+/**
+ * @internal
+ */
+exports.resolveConfig = (amplify) => {
+    const { apiKey, customEndpoint, customEndpointRegion, defaultAuthMode, endpoint, region, } = amplify.getConfig().API?.GraphQL ?? {};
+    // TODO: re-enable when working in all test environments:
+    // assertValidationError(!!endpoint, APIValidationErrorCode.NoEndpoint);
+    errors_1.assertValidationError(!(!customEndpoint && customEndpointRegion), errors_1.APIValidationErrorCode.NoCustomEndpoint);
+    return {
+        apiKey,
+        customEndpoint,
+        customEndpointRegion,
+        defaultAuthMode,
+        endpoint,
+        region,
+    };
+};

package/lib/utils/resolveLibraryOptions.d.ts

@@ -0,0 +1,11 @@
+import { AmplifyClassV6 } from '@aws-amplify/core';
+/**
+ * @internal
+ */
+export declare const resolveLibraryOptions: (amplify: AmplifyClassV6) => {
+    headers: ((options: {
+        query: string;
+        variables?: Record<string, import("@aws-amplify/core/lib-esm/libraryUtils").DocumentType> | undefined;
+    }) => Promise<Record<string, string>>) | undefined;
+    withCredentials: boolean | undefined;
+};

package/lib/utils/resolveLibraryOptions.js

@@ -0,0 +1,12 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @internal
+ */
+exports.resolveLibraryOptions = (amplify) => {
+    const headers = amplify.libraryOptions?.API?.GraphQL?.headers;
+    const withCredentials = amplify.libraryOptions?.API?.GraphQL?.withCredentials;
+    return { headers, withCredentials };
+};

package/lib-esm/GraphQLAPI.d.ts

@@ -1,10 +1,11 @@
+import { AmplifyClassV6 } from '@aws-amplify/core';
 import { GraphQLOptions, GraphQLResult } from './types';
 import { InternalGraphQLAPIClass } from './internals';
-import Observable from 'zen-observable-ts';
-export declare const graphqlOperation: (query: any, variables?: {}, authToken?: string) => {
+import { Observable } from 'rxjs';
+export declare const graphqlOperation: (query: any, variables?: {}, authToken?: string | undefined) => {
     query: any;
     variables: {};
-    authToken: string;
+    authToken: string | undefined;
 };
 /**
  * Export Cloud Logic APIs
@@ -18,8 +19,20 @@ export declare class GraphQLAPIClass extends InternalGraphQLAPIClass {
      * @param [additionalHeaders] - headers to merge in after any `graphql_headers` set in the config
      * @returns An Observable if the query is a subscription query, else a promise of the graphql result.
      */
-    graphql<T = any>(options: GraphQLOptions, additionalHeaders?: {
+    graphql<T = any>(amplify: AmplifyClassV6 | (() => Promise<AmplifyClassV6>), options: GraphQLOptions, additionalHeaders?: {
         [key: string]: string;
     }): Observable<GraphQLResult<T>> | Promise<GraphQLResult<T>>;
+    /**
+     * Checks to see if an error thrown is from an api request cancellation
+     * @param error - Any error
+     * @returns A boolean indicating if the error was from an api request cancellation
+     */
+    isCancelError(error: any): boolean;
+    /**
+     * Cancels an inflight request. Only applicable for graphql queries and mutations
+     * @param {any} request - request to cancel
+     * @returns A boolean indicating if the request was cancelled
+     */
+    cancel(request: Promise<any>, message?: string): boolean;
 }
 export declare const GraphQLAPI: GraphQLAPIClass;

package/lib-esm/GraphQLAPI.js

@@ -1,27 +1,17 @@
-import { __extends } from "tslib";
-// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-import { Amplify } from '@aws-amplify/core';
+import { Category, ApiAction } from '@aws-amplify/core/internals/utils';
 import { InternalGraphQLAPIClass } from './internals';
-export var graphqlOperation = function (query, variables, authToken) {
-    if (variables === void 0) { variables = {}; }
-    return ({
-        query: query,
-        variables: variables,
-        authToken: authToken,
-    });
-};
+export const graphqlOperation = (query, variables = {}, authToken) => ({
+    query,
+    variables,
+    authToken,
+});
 /**
  * Export Cloud Logic APIs
  */
-var GraphQLAPIClass = /** @class */ (function (_super) {
-    __extends(GraphQLAPIClass, _super);
-    function GraphQLAPIClass() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    GraphQLAPIClass.prototype.getModuleName = function () {
+export class GraphQLAPIClass extends InternalGraphQLAPIClass {
+    getModuleName() {
         return 'GraphQLAPI';
-    };
+    }
     /**
      * Executes a GraphQL operation
      *
@@ -29,12 +19,27 @@ var GraphQLAPIClass = /** @class */ (function (_super) {
      * @param [additionalHeaders] - headers to merge in after any `graphql_headers` set in the config
      * @returns An Observable if the query is a subscription query, else a promise of the graphql result.
      */
-    GraphQLAPIClass.prototype.graphql = function (options, additionalHeaders) {
-        return _super.prototype.graphql.call(this, options, additionalHeaders);
-    };
-    return GraphQLAPIClass;
-}(InternalGraphQLAPIClass));
-export { GraphQLAPIClass };
-export var GraphQLAPI = new GraphQLAPIClass(null);
-Amplify.register(GraphQLAPI);
-//# sourceMappingURL=GraphQLAPI.js.map
+    graphql(amplify, options, additionalHeaders) {
+        return super.graphql(amplify, options, additionalHeaders, {
+            category: Category.API,
+            action: ApiAction.GraphQl,
+        });
+    }
+    /**
+     * Checks to see if an error thrown is from an api request cancellation
+     * @param error - Any error
+     * @returns A boolean indicating if the error was from an api request cancellation
+     */
+    isCancelError(error) {
+        return super.isCancelError(error);
+    }
+    /**
+     * Cancels an inflight request. Only applicable for graphql queries and mutations
+     * @param {any} request - request to cancel
+     * @returns A boolean indicating if the request was cancelled
+     */
+    cancel(request, message) {
+        return super.cancel(request, message);
+    }
+}
+export const GraphQLAPI = new GraphQLAPIClass(null);

package/lib-esm/Providers/AWSAppSyncRealTimeProvider/index.d.ts

@@ -0,0 +1,64 @@
+import { Observable } from 'rxjs';
+import { GraphQLAuthMode, CustomUserAgentDetails, DocumentType } from '@aws-amplify/core/internals/utils';
+import { PubSubContentObserver } from '../../types/PubSub';
+import { SUBSCRIPTION_STATUS } from '../constants';
+export declare type ObserverQuery = {
+    observer: PubSubContentObserver;
+    query: string;
+    variables: Record<string, DocumentType>;
+    subscriptionState: SUBSCRIPTION_STATUS;
+    subscriptionReadyCallback?: Function;
+    subscriptionFailedCallback?: Function;
+    startAckTimeoutId?: ReturnType<typeof setTimeout>;
+};
+export interface AWSAppSyncRealTimeProviderOptions {
+    appSyncGraphqlEndpoint?: string;
+    authenticationType?: GraphQLAuthMode;
+    query?: string;
+    variables?: Record<string, DocumentType>;
+    apiKey?: string;
+    region?: string;
+    graphql_headers?: () => {} | (() => Promise<{}>);
+    additionalHeaders?: {
+        [key: string]: string;
+    };
+}
+export declare class AWSAppSyncRealTimeProvider {
+    private awsRealTimeSocket?;
+    private socketStatus;
+    private keepAliveTimeoutId?;
+    private keepAliveTimeout;
+    private keepAliveAlertTimeoutId?;
+    private subscriptionObserverMap;
+    private promiseArray;
+    private connectionState;
+    private readonly connectionStateMonitor;
+    private readonly reconnectionMonitor;
+    private connectionStateMonitorSubscription;
+    constructor(options?: AWSAppSyncRealTimeProviderOptions);
+    /**
+     * Mark the socket closed and release all active listeners
+     */
+    close(): void;
+    getNewWebSocket(url: string, protocol: string): WebSocket;
+    getProviderName(): string;
+    private isCustomDomain;
+    subscribe(options?: AWSAppSyncRealTimeProviderOptions, customUserAgentDetails?: CustomUserAgentDetails): Observable<Record<string, unknown>>;
+    private _startSubscriptionWithAWSAppSyncRealTime;
+    private _logStartSubscriptionError;
+    private _waitForSubscriptionToBeConnected;
+    private _sendUnsubscriptionMessage;
+    private _removeSubscriptionObserver;
+    private _closeSocketIfRequired;
+    private _handleIncomingSubscriptionMessage;
+    private _errorDisconnect;
+    private _timeoutStartSubscriptionAck;
+    private _initializeWebSocketConnection;
+    private _initializeRetryableHandshake;
+    private _initializeHandshake;
+    private _awsRealTimeHeaderBasedAuth;
+    private _awsAuthTokenHeader;
+    private _awsRealTimeApiKeyHeader;
+    private _awsRealTimeIAMHeader;
+    private _customAuthHeader;
+}