@aws-amplify/api-graphql 3.4.11 → 4.0.1-console-preview.047a1dd.0

package/src/types/index.ts

@@ -1,20 +1,25 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-import { Source, DocumentNode, GraphQLError, OperationTypeNode } from 'graphql';
+import { Source, DocumentNode, GraphQLError } from 'graphql';
 export { OperationTypeNode } from 'graphql';
-import { GRAPHQL_AUTH_MODE } from '@aws-amplify/auth';
-export { GRAPHQL_AUTH_MODE };
-import { CustomUserAgentDetails } from '@aws-amplify/core';
+import { Observable } from 'zen-observable-ts';
 
+import { DocumentType } from '@aws-amplify/api-rest';
+export type GraphQLAuthMode = 'AWS_IAM' | 'COGNITO_USERPOOLS' | 'API_KEY';
+
+/**
+ * Loose/Unknown options for raw GraphQLAPICategory `graphql()`.
+ */
 export interface GraphQLOptions {
 	query: string | DocumentNode;
-	variables?: object;
-	authMode?: keyof typeof GRAPHQL_AUTH_MODE;
+	variables?: Record<string, DocumentType>;
+	// authMode?: GraphQLAuthMode;
+	authMode?: string;
 	authToken?: string;
 	/**
 	 * @deprecated This property should not be used
 	 */
-	userAgentSuffix?: string; // TODO: remove in v6
+	userAgentSuffix?: string;
 }
 
 export interface GraphQLResult<T = object> {
@@ -25,6 +30,75 @@ export interface GraphQLResult<T = object> {
 	};
 }
 
+// Opaque type used for determining the graphql query type
+declare const queryType: unique symbol;
+
+export type GraphQLQuery<T> = T & { readonly [queryType]: 'query' };
+export type GraphQLSubscription<T> = T & {
+	readonly [queryType]: 'subscription';
+};
+
+/**
+ * The return value from a `graphql({query})` call when `query` is a subscription.
+ *
+ * ```ts
+ * //               |-- You are here
+ * //               v
+ * const subResult: GraphqlSubscriptionResult<T> = client.graphql({
+ * 	query: onCreateWidget
+ * });
+ *
+ * const sub = subResult.subscribe({
+ * 	//
+ * 	//            |-- You are here
+ * 	//            v
+ * 	next(message: GraphqlSubscriptionMessage<OnCreateWidgetSubscription>) {
+ * 		handle(message.value);  // <-- type OnCreateWidgetSubscription
+ * 	}
+ * })
+ * ```
+ */
+export type GraphqlSubscriptionResult<T> = Observable<
+	GraphqlSubscriptionMessage<T>
+>;
+
+/**
+ * The shape of messages passed to `next()` from a graphql subscription. E.g.,
+ *
+ * ```ts
+ * const sub = client.graphql({
+ * 	query: onCreateWidget,
+ * }).subscribe({
+ * 	//
+ * 	//            |-- You are here
+ * 	//            v
+ * 	next(message: GraphqlSubscriptionMessage<OnCreateWidgetSubscription>) {
+ * 		handle(message.value);  // <-- type OnCreateWidgetSubscription
+ * 	}
+ * })
+ * ```
+ */
+export type GraphqlSubscriptionMessage<T> = {
+	data?: T;
+};
+
+export interface AWSAppSyncRealTimeProviderOptions {
+	appSyncGraphqlEndpoint?: string;
+	authenticationType?: GraphQLAuthMode;
+	query?: string;
+	variables?: Record<string, unknown>;
+	apiKey?: string;
+	region?: string;
+	graphql_headers?: () => {} | (() => Promise<{}>);
+	additionalHeaders?: { [key: string]: string };
+}
+
+export type AWSAppSyncRealTimeProvider = {
+	subscribe(
+		options?: AWSAppSyncRealTimeProviderOptions
+	): Observable<Record<string, unknown>>;
+};
+
 export enum GraphQLAuthError {
 	NO_API_KEY = 'No api-key configured',
 	NO_CURRENT_USER = 'No current user',
@@ -38,3 +112,156 @@ export enum GraphQLAuthError {
  * @see: https://graphql.org/graphql-js/language/#parse
  */
 export type GraphQLOperation = Source | string;
+
+/**
+ * API V6 `graphql({options})` type that can leverage branded graphql `query`
+ * objects and fallback types.
+ */
+export interface GraphQLOptionsV6<
+	FALLBACK_TYPES = unknown,
+	TYPED_GQL_STRING extends string = string
+> {
+	query: TYPED_GQL_STRING | DocumentNode;
+	variables?: GraphQLVariablesV6<FALLBACK_TYPES, TYPED_GQL_STRING>;
+	authMode?: GraphQLAuthMode;
+	authToken?: string;
+	/**
+	 * @deprecated This property should not be used
+	 */
+	userAgentSuffix?: string;
+}
+
+/**
+ * Result type for `graphql()` operations that don't include any specific
+ * type information. The result could be either a `Promise` or `Subscription`.
+ *
+ * Invoking code should either cast the result or use `?` and `!` operators to
+ * navigate the result objects.
+ */
+export type UnknownGraphQLResponse =
+	| Promise<GraphQLResult<any>>
+	| GraphqlSubscriptionResult<any>;
+
+/**
+ * The expected type for `variables` in a V6 `graphql()` operation with
+ * respect to the given `FALLBACK_TYPES` and `TYPED_GQL_STRING`.
+ */
+export type GraphQLVariablesV6<
+	FALLBACK_TYPES = unknown,
+	TYPED_GQL_STRING extends string = string
+> = TYPED_GQL_STRING extends GeneratedQuery<infer IN, any>
+	? IN
+	: TYPED_GQL_STRING extends GeneratedMutation<infer IN, any>
+	? IN
+	: TYPED_GQL_STRING extends GeneratedSubscription<infer IN, any>
+	? IN
+	: FALLBACK_TYPES extends GraphQLOperationType<infer IN, any>
+	? IN
+	: any;
+
+/**
+ * The expected return type with respect to the given `FALLBACK_TYPE`
+ * and `TYPED_GQL_STRING`.
+ */
+export type GraphQLResponseV6<
+	FALLBACK_TYPE = unknown,
+	TYPED_GQL_STRING extends string = string
+> = TYPED_GQL_STRING extends GeneratedQuery<infer IN, infer QUERY_OUT>
+	? Promise<GraphQLResult<QUERY_OUT>>
+	: TYPED_GQL_STRING extends GeneratedMutation<infer IN, infer MUTATION_OUT>
+	? Promise<GraphQLResult<MUTATION_OUT>>
+	: TYPED_GQL_STRING extends GeneratedSubscription<infer IN, infer SUB_OUT>
+	? GraphqlSubscriptionResult<SUB_OUT>
+	: FALLBACK_TYPE extends GraphQLQuery<infer T>
+	? Promise<GraphQLResult<FALLBACK_TYPE>>
+	: FALLBACK_TYPE extends GraphQLSubscription<infer T>
+	? GraphqlSubscriptionResult<FALLBACK_TYPE>
+	: FALLBACK_TYPE extends GraphQLOperationType<infer IN, infer CUSTOM_OUT>
+	? CUSTOM_OUT
+	: UnknownGraphQLResponse;
+
+/**
+ * The shape customers can use to provide `T` to `graphql<T>()` to specify both
+ * `IN` and `OUT` types (the type of `variables` and the return type, respectively).
+ *
+ * I.E.,
+ *
+ * ```ts
+ * type MyVariablesType = { ... };
+ * type MyResultType = { ... };
+ * type MyOperationType = { variables: MyVariablesType, result: MyResultType };
+ *
+ * const result: MyResultType = graphql<MyOperationType>("graphql string", {
+ * 	variables: {
+ * 		// MyVariablesType
+ * 	}
+ * })
+ * ```
+ */
+export type GraphQLOperationType<IN extends {}, OUT extends {}> = {
+	variables: IN;
+	result: OUT;
+};
+
+/**
+ * Nominal type for branding generated graphql query operation strings with
+ * input and output types.
+ *
+ * E.g.,
+ *
+ * ```ts
+ * export const getWidget = `...` as GeneratedQuery<
+ * 	GetWidgetQueryVariables,
+ * 	GetWidgetQuery
+ * >;
+ * ```
+ *
+ * This allows `graphql()` to extract `InputType` and `OutputType` to correctly
+ * assign types to the `variables` and result objects.
+ */
+export type GeneratedQuery<InputType, OutputType> = string & {
+	__generatedQueryInput: InputType;
+	__generatedQueryOutput: OutputType;
+};
+
+/**
+ * Nominal type for branding generated graphql mutation operation strings with
+ * input and output types.
+ *
+ * E.g.,
+ *
+ * ```ts
+ * export const createWidget = `...` as GeneratedQuery<
+ * 	CreateWidgetMutationVariables,
+ * 	CreateWidgetMutation
+ * >;
+ * ```
+ *
+ * This allows `graphql()` to extract `InputType` and `OutputType` to correctly
+ * assign types to the `variables` and result objects.
+ */
+export type GeneratedMutation<InputType, OutputType> = string & {
+	__generatedMutationInput: InputType;
+	__generatedMutationOutput: OutputType;
+};
+
+/**
+ * Nominal type for branding generated graphql mutation operation strings with
+ * input and output types.
+ *
+ * E.g.,
+ *
+ * ```ts
+ * export const createWidget = `...` as GeneratedMutation<
+ * 	CreateWidgetMutationVariables,
+ * 	CreateWidgetMutation
+ * >;
+ * ```
+ *
+ * This allows `graphql()` to extract `InputType` and `OutputType` to correctly
+ * assign types to the `variables` and result objects.
+ */
+export type GeneratedSubscription<InputType, OutputType> = string & {
+	__generatedSubscriptionInput: InputType;
+	__generatedSubscriptionOutput: OutputType;
+};

package/src/utils/ConnectionStateMonitor.ts

@@ -0,0 +1,195 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import Observable, { ZenObservable } from 'zen-observable-ts';
+import { ConnectionState } from '../types/PubSub';
+import { ReachabilityMonitor } from './ReachabilityMonitor';
+
+// Internal types for tracking different connection states
+type LinkedConnectionState = 'connected' | 'disconnected';
+type LinkedHealthState = 'healthy' | 'unhealthy';
+type LinkedConnectionStates = {
+	networkState: LinkedConnectionState;
+	connectionState: LinkedConnectionState | 'connecting';
+	intendedConnectionState: LinkedConnectionState;
+	keepAliveState: LinkedHealthState;
+};
+
+export const CONNECTION_CHANGE: {
+	[key in
+		| 'KEEP_ALIVE_MISSED'
+		| 'KEEP_ALIVE'
+		| 'CONNECTION_ESTABLISHED'
+		| 'CONNECTION_FAILED'
+		| 'CLOSING_CONNECTION'
+		| 'OPENING_CONNECTION'
+		| 'CLOSED'
+		| 'ONLINE'
+		| 'OFFLINE']: Partial<LinkedConnectionStates>;
+} = {
+	KEEP_ALIVE_MISSED: { keepAliveState: 'unhealthy' },
+	KEEP_ALIVE: { keepAliveState: 'healthy' },
+	CONNECTION_ESTABLISHED: { connectionState: 'connected' },
+	CONNECTION_FAILED: {
+		intendedConnectionState: 'disconnected',
+		connectionState: 'disconnected',
+	},
+	CLOSING_CONNECTION: { intendedConnectionState: 'disconnected' },
+	OPENING_CONNECTION: {
+		intendedConnectionState: 'connected',
+		connectionState: 'connecting',
+	},
+	CLOSED: { connectionState: 'disconnected' },
+	ONLINE: { networkState: 'connected' },
+	OFFLINE: { networkState: 'disconnected' },
+};
+
+export class ConnectionStateMonitor {
+	/**
+	 * @private
+	 */
+	private _linkedConnectionState: LinkedConnectionStates;
+	private _linkedConnectionStateObservable: Observable<LinkedConnectionStates>;
+	private _linkedConnectionStateObserver: ZenObservable.SubscriptionObserver<LinkedConnectionStates>;
+	private _networkMonitoringSubscription?: ZenObservable.Subscription;
+	private _initialNetworkStateSubscription?: ZenObservable.Subscription;
+
+	constructor() {
+		this._networkMonitoringSubscription = undefined;
+		this._linkedConnectionState = {
+			networkState: 'connected',
+			connectionState: 'disconnected',
+			intendedConnectionState: 'disconnected',
+			keepAliveState: 'healthy',
+		};
+
+		// Attempt to update the state with the current actual network state
+		this._initialNetworkStateSubscription = ReachabilityMonitor().subscribe(
+			({ online }) => {
+				this.record(
+					online ? CONNECTION_CHANGE.ONLINE : CONNECTION_CHANGE.OFFLINE
+				);
+				this._initialNetworkStateSubscription?.unsubscribe();
+			}
+		);
+
+		this._linkedConnectionStateObservable =
+			new Observable<LinkedConnectionStates>(connectionStateObserver => {
+				connectionStateObserver.next(this._linkedConnectionState);
+				this._linkedConnectionStateObserver = connectionStateObserver;
+			});
+	}
+
+	/**
+	 * Turn network state monitoring on if it isn't on already
+	 */
+	private enableNetworkMonitoring() {
+		// If no initial network state was discovered, stop trying
+		this._initialNetworkStateSubscription?.unsubscribe();
+
+		// Maintain the network state based on the reachability monitor
+		if (this._networkMonitoringSubscription === undefined) {
+			this._networkMonitoringSubscription = ReachabilityMonitor().subscribe(
+				({ online }) => {
+					this.record(
+						online ? CONNECTION_CHANGE.ONLINE : CONNECTION_CHANGE.OFFLINE
+					);
+				}
+			);
+		}
+	}
+
+	/**
+	 * Turn network state monitoring off if it isn't off already
+	 */
+	private disableNetworkMonitoring() {
+		this._networkMonitoringSubscription?.unsubscribe();
+		this._networkMonitoringSubscription = undefined;
+	}
+
+	/**
+	 * Get the observable that allows us to monitor the connection state
+	 *
+	 * @returns {Observable<ConnectionState>} - The observable that emits ConnectionState updates
+	 */
+	public get connectionStateObservable(): Observable<ConnectionState> {
+		let previous: ConnectionState;
+
+		// The linked state aggregates state changes to any of the network, connection,
+		// intendedConnection and keepAliveHealth. Some states will change these independent
+		// states without changing the overall connection state.
+
+		// After translating from linked states to ConnectionState, then remove any duplicates
+		return this._linkedConnectionStateObservable
+			.map(value => {
+				return this.connectionStatesTranslator(value);
+			})
+			.filter(current => {
+				const toInclude = current !== previous;
+				previous = current;
+				return toInclude;
+			});
+	}
+
+	/*
+	 * Updates local connection state and emits the full state to the observer.
+	 */
+	record(statusUpdates: Partial<LinkedConnectionStates>) {
+		// Maintain the network monitor
+		if (statusUpdates.intendedConnectionState === 'connected') {
+			this.enableNetworkMonitoring();
+		} else if (statusUpdates.intendedConnectionState === 'disconnected') {
+			this.disableNetworkMonitoring();
+		}
+
+		// Maintain the socket state
+		const newSocketStatus = {
+			...this._linkedConnectionState,
+			...statusUpdates,
+		};
+
+		this._linkedConnectionState = { ...newSocketStatus };
+
+		this._linkedConnectionStateObserver.next(this._linkedConnectionState);
+	}
+
+	/*
+	 * Translate the ConnectionState structure into a specific ConnectionState string literal union
+	 */
+	private connectionStatesTranslator({
+		connectionState,
+		networkState,
+		intendedConnectionState,
+		keepAliveState,
+	}: LinkedConnectionStates): ConnectionState {
+		if (connectionState === 'connected' && networkState === 'disconnected')
+			return ConnectionState.ConnectedPendingNetwork;
+
+		if (
+			connectionState === 'connected' &&
+			intendedConnectionState === 'disconnected'
+		)
+			return ConnectionState.ConnectedPendingDisconnect;
+
+		if (
+			connectionState === 'disconnected' &&
+			intendedConnectionState === 'connected' &&
+			networkState === 'disconnected'
+		)
+			return ConnectionState.ConnectionDisruptedPendingNetwork;
+
+		if (
+			connectionState === 'disconnected' &&
+			intendedConnectionState === 'connected'
+		)
+			return ConnectionState.ConnectionDisrupted;
+
+		if (connectionState === 'connected' && keepAliveState === 'unhealthy')
+			return ConnectionState.ConnectedPendingKeepAlive;
+
+		// All remaining states directly correspond to the connection state
+		if (connectionState === 'connecting') return ConnectionState.Connecting;
+		if (connectionState === 'disconnected') return ConnectionState.Disconnected;
+		return ConnectionState.Connected;
+	}
+}

package/src/utils/ReachabilityMonitor/index.native.ts

@@ -0,0 +1,7 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { Reachability } from '@aws-amplify/core/internals/utils';
+import { default as NetInfo } from '@react-native-community/netinfo';
+
+export const ReachabilityMonitor = () =>
+	new Reachability().networkMonitor(NetInfo);

package/src/utils/ReachabilityMonitor/index.ts

@@ -0,0 +1,4 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { Reachability } from '@aws-amplify/core/internals/utils';
+export const ReachabilityMonitor = () => new Reachability().networkMonitor();

package/src/utils/ReconnectionMonitor.ts

@@ -0,0 +1,76 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { Observer } from 'zen-observable-ts';
+import { RECONNECT_DELAY, RECONNECT_INTERVAL } from '../Providers/constants';
+
+export enum ReconnectEvent {
+	START_RECONNECT = 'START_RECONNECT',
+	HALT_RECONNECT = 'HALT_RECONNECT',
+}
+
+/**
+ * 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.
+ */
+export class ReconnectionMonitor {
+	private reconnectObservers: Observer<void>[] = [];
+	private reconnectIntervalId?: ReturnType<typeof setInterval>;
+	private reconnectSetTimeoutId?: ReturnType<typeof setTimeout>;
+
+	/**
+	 * Add reconnect observer to the list of observers to alert on reconnect
+	 */
+	addObserver(reconnectObserver: Observer<void>) {
+		this.reconnectObservers.push(reconnectObserver);
+	}
+
+	/**
+	 * Given a reconnect event, start the appropriate behavior
+	 */
+	record(event: ReconnectEvent) {
+		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();
+					}, RECONNECT_INTERVAL);
+				}, 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?.();
+		});
+	}
+
+	private _triggerReconnect() {
+		this.reconnectObservers.forEach(reconnectObserver => {
+			reconnectObserver.next?.();
+		});
+	}
+}

package/src/utils/errors/APIError.ts

@@ -0,0 +1,18 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { AmplifyError, ErrorParams } from '@aws-amplify/core/internals/utils';
+
+/**
+ * @internal
+ */
+export class APIError extends AmplifyError {
+	constructor(params: ErrorParams) {
+		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);
+	}
+}

package/src/utils/errors/assertValidationError.ts

@@ -0,0 +1,19 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { APIError } from './APIError';
+import { APIValidationErrorCode, validationErrorMap } from './validation';
+
+/**
+ * @internal
+ */
+export function assertValidationError(
+	assertion: boolean,
+	name: APIValidationErrorCode
+): asserts assertion {
+	const { message, recoverySuggestion } = validationErrorMap[name];
+
+	if (!assertion) {
+		throw new APIError({ name, message, recoverySuggestion });
+	}
+}

package/src/utils/errors/index.ts

@@ -0,0 +1,6 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+export { APIError } from './APIError';
+export { assertValidationError } from './assertValidationError';
+export { APIValidationErrorCode, validationErrorMap } from './validation';

package/src/utils/errors/validation.ts

@@ -0,0 +1,26 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { AmplifyErrorMap } from '@aws-amplify/core/internals/utils';
+
+export enum APIValidationErrorCode {
+	NoAppId = 'NoAppId',
+	NoCredentials = 'NoCredentials',
+	NoRegion = 'NoRegion',
+	NoDefaultAuthMode = 'NoDefaultAuthMode',
+}
+
+export const validationErrorMap: AmplifyErrorMap<APIValidationErrorCode> = {
+	[APIValidationErrorCode.NoAppId]: {
+		message: 'Missing application id.',
+	},
+	[APIValidationErrorCode.NoCredentials]: {
+		message: 'Credentials should not be empty.',
+	},
+	[APIValidationErrorCode.NoRegion]: {
+		message: 'Missing region.',
+	},
+	[APIValidationErrorCode.NoDefaultAuthMode]: {
+		message: 'Missing default auth mode',
+	},
+};

package/src/utils/index.ts

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

package/src/utils/resolveConfig.ts

@@ -0,0 +1,20 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { Amplify } from '@aws-amplify/core';
+import { APIValidationErrorCode, assertValidationError } from './errors';
+
+/**
+ * @internal
+ */
+export const resolveConfig = () => {
+	const { region, defaultAuthMode, endpoint } =
+		Amplify.getConfig().API?.AppSync ?? {};
+	assertValidationError(!!endpoint, APIValidationErrorCode.NoAppId);
+	assertValidationError(!!region, APIValidationErrorCode.NoRegion);
+	assertValidationError(
+		!!defaultAuthMode,
+		APIValidationErrorCode.NoDefaultAuthMode
+	);
+	return { endpoint, region, defaultAuthMode };
+};

package/src/utils/resolveCredentials.ts

@@ -0,0 +1,14 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { fetchAuthSession } from '@aws-amplify/core';
+import { APIValidationErrorCode, assertValidationError } from './errors';
+
+/**
+ * @internal
+ */
+export const resolveCredentials = async () => {
+	const { credentials, identityId } = await fetchAuthSession();
+	assertValidationError(!!credentials, APIValidationErrorCode.NoCredentials);
+	return { credentials, identityId };
+};

package/lib/.tsbuildinfo

@@ -1,3 +0,0 @@
-{
-  "version": "3.8.3"
-}

package/lib/GraphQLAPI.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"GraphQLAPI.js","sourceRoot":"","sources":["../src/GraphQLAPI.ts"],"names":[],"mappings":";;;AAAA,qEAAqE;AACrE,sCAAsC;AACtC,0CAA4C;AAE5C,yCAAsD;AAGzC,QAAA,gBAAgB,GAAG,UAC/B,KAAK,EACL,SAAc,EACd,SAAkB;IADlB,0BAAA,EAAA,cAAc;IAEV,OAAA,CAAC;QACL,KAAK,OAAA;QACL,SAAS,WAAA;QACT,SAAS,WAAA;KACT,CAAC;AAJG,CAIH,CAAC;AAEH;;GAEG;AACH;IAAqC,2CAAuB;IAA5D;;IAkBA,CAAC;IAjBO,uCAAa,GAApB;QACC,OAAO,YAAY,CAAC;IACrB,CAAC;IAED;;;;;;OAMG;IACH,iCAAO,GAAP,UACC,OAAuB,EACvB,iBAA6C;QAE7C,OAAO,iBAAM,OAAO,YAAC,OAAO,EAAE,iBAAiB,CAAC,CAAC;IAClD,CAAC;IACF,sBAAC;AAAD,CAAC,AAlBD,CAAqC,mCAAuB,GAkB3D;AAlBY,0CAAe;AAoBf,QAAA,UAAU,GAAG,IAAI,eAAe,CAAC,IAAI,CAAC,CAAC;AACpD,cAAO,CAAC,QAAQ,CAAC,kBAAU,CAAC,CAAC"}

package/lib/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA,qEAAqE;AACrE,sCAAsC;;;AAEtC,2CAA0C;AAC1C,iCAA6E;AAArD,mCAAA,gBAAgB,CAAA;AAAE,oCAAA,iBAAiB,CAAA;AAC3D,2CAA6E;AAApE,kCAAA,UAAU,CAAA;AAAE,uCAAA,eAAe,CAAA;AAAE,wCAAA,gBAAgB,CAAA;AACtD,kDAAwB;AACxB,kBAAe,uBAAU,CAAC"}