@aws-amplify/core 4.7.7-unstable.7 → 4.7.7

package/src/Credentials.ts

@@ -187,7 +187,7 @@ export class CredentialsClass {
 		const MAX_DELAY_MS = 10 * 1000;
 		// refreshHandler will retry network errors, otherwise it will
 		// return NonRetryableError to break out of jitteredExponentialRetry
-		return jitteredExponentialRetry<any>(refreshHandler, [], MAX_DELAY_MS)
+		return jitteredExponentialRetry(refreshHandler, [], MAX_DELAY_MS)
 			.then(data => {
 				logger.debug('refresh federated token sucessfully', data);
 				return this._setCredentialsFromFederation({
@@ -256,7 +256,7 @@ export class CredentialsClass {
 			);
 		}
 
-		const identityId = (this._identityId = await this._getGuestIdentityId());
+		const identityId = this._identityId = await this._getGuestIdentityId();
 
 		const cognitoClient = new CognitoIdentityClient({
 			region,
@@ -446,14 +446,19 @@ export class CredentialsClass {
 			}
 
 			const {
-				Credentials: { AccessKeyId, Expiration, SecretKey, SessionToken },
+				Credentials: {
+					AccessKeyId,
+					Expiration,
+					SecretKey,
+					SessionToken,
+				},
 				// single source of truth for the primary identity associated with the logins
 				// only if a guest identity is used for a first-time user, that guest identity will become its primary identity
 				IdentityId: primaryIdentityId,
 			} = await cognitoClient.send(
 				new GetCredentialsForIdentityCommand({
-					IdentityId: guestIdentityId || generatedOrRetrievedIdentityId,
-					Logins: logins,
+				  IdentityId: guestIdentityId || generatedOrRetrievedIdentityId,
+				  Logins: logins,
 				})
 			);
 
@@ -461,13 +466,9 @@ export class CredentialsClass {
 			if (guestIdentityId) {
 				// if guestIdentity is found and used by GetCredentialsForIdentity
 				// it will be linked to the logins provided, and disqualified as an unauth identity
-				logger.debug(
-					`The guest identity ${guestIdentityId} has been successfully linked to the logins`
-				);
+				logger.debug(`The guest identity ${guestIdentityId} has been successfully linked to the logins`);
 				if (guestIdentityId === primaryIdentityId) {
-					logger.debug(
-						`The guest identity ${guestIdentityId} has become the primary identity`
-					);
+					logger.debug(`The guest identity ${guestIdentityId} has become the primary identity`);
 				}
 				// remove it from local storage to avoid being used as a guest Identity by _setCredentialsForGuest
 				await this._removeGuestIdentityId();
@@ -480,7 +481,7 @@ export class CredentialsClass {
 				sessionToken: SessionToken,
 				expiration: Expiration,
 				identityId: primaryIdentityId,
-			};
+			  };
 		};
 
 		const credentials = credentialsProvider().catch(async err => {
@@ -586,7 +587,7 @@ export class CredentialsClass {
 			await this._storageSync;
 			this._storage.setItem(
 				this._getCognitoIdentityIdStorageKey(identityPoolId),
-				identityId
+				identityId,
 			);
 		} catch (e) {
 			logger.debug('Failed to cache guest identityId', e);

package/src/Util/Retry.ts

@@ -18,74 +18,41 @@ const isNonRetryableError = (obj: any): obj is NonRetryableError => {
  * @private
  * Internal use of Amplify only
  */
-export async function retry<T>(
-	functionToRetry: (...args: any[]) => T,
+export async function retry(
+	functionToRetry: Function,
 	args: any[],
 	delayFn: DelayFunction,
-	onTerminate?: Promise<void>
-): Promise<T> {
+	attempt: number = 1
+) {
 	if (typeof functionToRetry !== 'function') {
 		throw Error('functionToRetry must be a function');
 	}
+	logger.debug(
+		`${
+			functionToRetry.name
+		} attempt #${attempt} with this vars: ${JSON.stringify(args)}`
+	);
+
+	try {
+		return await functionToRetry(...args);
+	} catch (err) {
+		logger.debug(`error on ${functionToRetry.name}`, err);
+
+		if (isNonRetryableError(err)) {
+			logger.debug(`${functionToRetry.name} non retryable error`, err);
+			throw err;
+		}
 
-	return new Promise(async (resolve, reject) => {
-		let attempt = 0;
-		let terminated = false;
-		let timeout: any;
-		let wakeUp: any = () => {}; // will be replaced with a resolver()
-
-		// used after the loop if terminated while waiting for a timer.
-		let lastError: Error;
-
-		onTerminate &&
-			onTerminate.then(() => {
-				// signal not to try anymore.
-				terminated = true;
-
-				// stop sleeping if we're sleeping.
-				clearTimeout(timeout);
-				wakeUp();
-			});
-
-		while (!terminated) {
-			attempt++;
-
-			logger.debug(
-				`${
-					functionToRetry.name
-				} attempt #${attempt} with this vars: ${JSON.stringify(args)}`
-			);
-
-			try {
-				return resolve(await functionToRetry(...args));
-			} catch (err) {
-				lastError = err;
-				logger.debug(`error on ${functionToRetry.name}`, err);
-
-				if (isNonRetryableError(err)) {
-					logger.debug(`${functionToRetry.name} non retryable error`, err);
-					return reject(err);
-				}
-
-				const retryIn = delayFn(attempt, args, err);
-				logger.debug(`${functionToRetry.name} retrying in ${retryIn} ms`);
+		const retryIn = delayFn(attempt, args, err);
+		logger.debug(`${functionToRetry.name} retrying in ${retryIn} ms`);
 
-				// we check `terminated` again here because it could have flipped
-				// in the time it took `functionToRetry` to return.
-				if (retryIn === false || terminated) {
-					return reject(err);
-				} else {
-					await new Promise(r => {
-						wakeUp = r; // export wakeUp for onTerminate handling
-						timeout = setTimeout(wakeUp, retryIn);
-					});
-				}
-			}
+		if (retryIn !== false) {
+			await new Promise(res => setTimeout(res, retryIn));
+			return await retry(functionToRetry, args, delayFn, attempt + 1);
+		} else {
+			throw err;
 		}
-
-		// reached if terminated while waiting for a timer.
-		reject(lastError);
-	});
+	}
 }
 
 const MAX_DELAY_MS = 5 * 60 * 1000;
@@ -110,10 +77,8 @@ export function jitteredBackoff(
  * @private
  * Internal use of Amplify only
  */
-export const jitteredExponentialRetry = <T>(
-	functionToRetry: (...args: any[]) => T,
+export const jitteredExponentialRetry = (
+	functionToRetry: Function,
 	args: any[],
-	maxDelayMs: number = MAX_DELAY_MS,
-	onTerminate?: Promise<void>
-): Promise<T> =>
-	retry(functionToRetry, args, jitteredBackoff(maxDelayMs), onTerminate);
+	maxDelayMs: number = MAX_DELAY_MS
+) => retry(functionToRetry, args, jitteredBackoff(maxDelayMs));

package/src/Util/index.ts

@@ -4,4 +4,3 @@ export { default as Reachability } from './Reachability';
 export * from './DateUtils';
 export * from './StringUtils';
 export * from './Constants';
-export * from './BackgroundProcessManager';

package/lib/Util/BackgroundProcessManager.d.ts

@@ -1,178 +0,0 @@
-/**
- * @private For internal Amplify use.
- *
- * Creates a new scope for promises, observables, and other types of work or
- * processes that may be running in the background. This manager provides
- * an singular entrypoint to request termination and await completion.
- *
- * As work completes on its own prior to close, the manager removes them
- * from the registry to avoid holding references to completed jobs.
- */
-export declare class BackgroundProcessManager {
-    /**
-     * A string indicating whether the manager is accepting new work ("Open"),
-     * waiting for work to complete ("Closing"), or fully done with all
-     * submitted work and *not* accepting new jobs ("Closed").
-     */
-    private _state;
-    /**
-     * The list of outstanding jobs we'll need to wait for upon `close()`
-     */
-    private jobs;
-    /**
-     * Creates a new manager for promises, observables, and other types
-     * of work that may be running in the background. This manager provides
-     * a centralized mechanism to request termination and await completion.
-     */
-    constructor();
-    /**
-     * Executes an async `job` function, passing the return value through to
-     * the caller, registering it as a running job in the manager. When the
-     * manager *closes*, it will `await` the job.
-     *
-     * @param job The function to execute.
-     * @param description Optional description to help identify pending jobs.
-     * @returns The return value from the given function.
-     */
-    add<T>(job: () => Promise<T>, description?: string): Promise<T>;
-    /**
-     * Executes an async `job` function, passing the return value through to
-     * the caller, registering it as a running job in the manager. When the
-     * manager *closes*, it will request termination by resolving the
-     * provided `onTerminate` promise. It will then `await` the job, so it is
-     * important that the job still `resolve()` or `reject()` when responding
-     * to a termination request.
-     *
-     * @param job The function to execute.
-     * @param description Optional description to help identify pending jobs.
-     * @returns The return value from the given function.
-     */
-    add<T>(job: (onTerminate: Promise<void>) => Promise<T>, description?: string): Promise<T>;
-    /**
-     * Create a no-op job, registers it with the manager, and returns hooks
-     * to the caller to signal the job's completion and respond to termination
-     * requests.
-     *
-     * When the manager closes, the no-op job will be `await`-ed, so its
-     * important to always `resolve()` or `reject()` when done responding to an
-     * `onTerminate` signal.
-     * @param description Optional description to help identify pending jobs.
-     * @returns Job promise hooks + onTerminate signaling promise
-     */
-    add(description?: string): {
-        resolve: (value?: unknown) => void;
-        reject: (reason?: any) => void;
-        onTerminate: Promise<void>;
-    };
-    /**
-     * Adds another job manager to await on at the time of closing. the inner
-     * manager's termination is signaled when this manager's `close()` is
-     * called for.
-     *
-     * @param job The inner job manager to await.
-     * @param description Optional description to help identify pending jobs.
-     */
-    add(job: BackgroundProcessManager, description?: string): any;
-    /**
-     * Adds a **cleaner** function that doesn't immediately get executed.
-     * Instead, the caller gets a **terminate** function back. The *cleaner* is
-     * invoked only once the mananger *closes* or the returned **terminate**
-     * function is called.
-     *
-     * @param clean The cleanup function.
-     * @param description Optional description to help identify pending jobs.
-     * @returns A terminate function.
-     */
-    addCleaner<T>(clean: () => Promise<T>, description?: string): () => Promise<void>;
-    private addFunction;
-    private addManager;
-    /**
-     * Creates and registers a fabricated job for processes that need to operate
-     * with callbacks/hooks. The returned `resolve` and `reject`
-     * functions can be used to signal the job is done successfully or not.
-     * The returned `onTerminate` is a promise that will resolve when the
-     * manager is requesting the termination of the job.
-     *
-     * @param description Optional description to help identify pending jobs.
-     * @returns `{ resolve, reject, onTerminate }`
-     */
-    private addHook;
-    /**
-     * Adds a Promise based job to the list of jobs for monitoring and listens
-     * for either a success or failure, upon which the job is considered "done"
-     * and removed from the registry.
-     *
-     * @param promise A promise that is on its way to being returned to a
-     * caller, which needs to be tracked as a background job.
-     * @param terminate The termination function to register, which can be
-     * invoked to request the job stop.
-     * @param description Optional description to help identify pending jobs.
-     */
-    private registerPromise;
-    /**
-     * The number of jobs being waited on.
-     *
-     * We don't use this for anything. It's just informational for the caller,
-     * and can be used in logging and testing.
-     *
-     * @returns the number of jobs.
-     */
-    get length(): number;
-    /**
-     * The execution state of the manager. One of:
-     *
-     * 1. "Open" -> Accepting new jobs
-     * 1. "Closing" -> Not accepting new work. Waiting for jobs to complete.
-     * 1. "Closed" -> Not accepting new work. All submitted jobs are complete.
-     */
-    get state(): BackgroundProcessManagerState;
-    /**
-     * The registered `description` of all still-pending jobs.
-     *
-     * @returns descriptions as an array.
-     */
-    get pending(): string[];
-    /**
-     * Whether the manager is accepting new jobs.
-     */
-    get isOpen(): boolean;
-    /**
-     * Whether the manager is rejecting new work, but still waiting for
-     * submitted work to complete.
-     */
-    get isClosing(): boolean;
-    /**
-     * Whether the manager is rejecting work and done waiting for submitted
-     * work to complete.
-     */
-    get isClosed(): boolean;
-    private closedFailure;
-    /**
-     * Signals jobs to stop (for those that accept interruptions) and waits
-     * for confirmation that jobs have stopped.
-     *
-     * This immediately puts the manager into a closing state and just begins
-     * to reject new work. After all work in the manager is complete, the
-     * manager goes into a `Completed` state and `close()` returns.
-     *
-     * @returns The settled results of each job's promise.
-     */
-    close(): Promise<PromiseSettledResult<any>[]>;
-}
-/**
- * All possible states a `BackgroundProcessManager` instance can be in.
- */
-export declare enum BackgroundProcessManagerState {
-    /**
-     * Accepting new jobs.
-     */
-    Open = "Open",
-    /**
-     * Not accepting new jobs. Waiting for submitted jobs to complete.
-     */
-    Closing = "Closing",
-    /**
-     * Not accepting new jobs. All submitted jobs are complete.
-     */
-    Closed = "Closed"
-}