Changes:

* Added isComplete method for PageIterator
* Updated delay to be added with exponential backoff value from second retry atttemp onwords
* Updated readme with details of dependencies
* Added proper handling for responses other than 2XX

Author: muthurathinam-m

README.md

@@ -22,24 +22,18 @@ import `@microsoft/microsoft-graph-client` into your module.
 import { Client } from "@microsoft/microsoft-graph-client";
 ```
 
-In case your environment have support for or have polyfill for [Fetch](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API) [[support](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API#Browser_compatibility)] and [Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise) [[support](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise#Browser_compatibility)], import `./node_modules/@microsoft/microsoft-graph-client/lib/src/core/index` into your module which doesn't have polyfills for these.
-
-```typescript
-import { Client } from "./node_modules/@microsoft/microsoft-graph-client/lib/src/core/index";
-```
-
 ### Via Script Tag
 
-Include `lib/graph-js-sdk-core.js` in your page.
+Include `lib/graph-js-sdk-web.js` in your page.
 
 ```HTML
-<script type="text/javascript" src="graph-js-sdk-core.js"></script>
+<script type="text/javascript" src="graph-js-sdk-web.js"></script>
 ```
 
-In case your browser doesn't have support for [Fetch](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API) [[support](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API#Browser_compatibility)] and [Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise) [[support](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise#Browser_compatibility)], you can polyfill them and include as above or you can use `lib/graph-js-sdk-web.js` which includes polyfills.
+Incase if your application ships with [es6-promise](https://www.npmjs.com/package/es6-promise) and [isomorphic-fetch](https://www.npmjs.com/package/isomorphic-fetch) just use `lib/graph-js-sdk-core.js`
 
 ```HTML
-<script type="text/javascript" src="graph-js-sdk-web.js"></script>
+<script type="text/javascript" src="graph-js-sdk-core.js"></script>
 ```
 
 ## Getting started

docs/tasks/PageIterator.md

@@ -47,8 +47,10 @@ async function customSize() {
 		pageIterator.iterate();
 
 		// Resuming will do start from where it left off and iterate for next 1000 entities.
-		// Resume is likely to be called in any user interaction requiring to load more data.
-		pageIterator.resume();
+		// Check and resume is likely to be called in any user interaction requiring to load more data.
+		if (!pageIterator.isComplete()) {
+			pageIterator.resume();
+		}
 	} catch (e) {
 		throw e;
 	}

spec/core/GraphErrorHandler.ts

@@ -30,6 +30,29 @@ describe("GraphErrorHandler.ts", () => {
 		});
 	});
 
+	describe("constructErrorFromRawResponse", async () => {
+		it("Should parse error from raw response", async () => {
+			const body = "unauthorized";
+			const statusCode = 401;
+			const errorResponse = new Response(body, {
+				status: statusCode,
+			});
+			const gError = await GraphErrorHandler["constructErrorFromRawResponse"](errorResponse, statusCode);
+			assert.equal(gError.statusCode, statusCode);
+			assert.equal(gError.body, body);
+		});
+
+		it("Should parse error without body", async () => {
+			const statusCode = 401;
+			const errorResponse = new Response(undefined, {
+				status: statusCode,
+			});
+			const gError = await GraphErrorHandler["constructErrorFromRawResponse"](errorResponse, statusCode);
+			assert.equal(gError.statusCode, statusCode);
+			assert.isNull(gError.body);
+		});
+	});
+
 	describe("constructErrorFromResponse", () => {
 		const statusCode = 400;
 		const error: any = {
@@ -69,8 +92,8 @@ describe("GraphErrorHandler.ts", () => {
 	});
 	/* tslint:enable: no-string-literal */
 
-	describe("getError", () => {
-		it("Should construct error from response", () => {
+	describe("getError", async () => {
+		it("Should construct error from response", async () => {
 			const errorResponse = {
 				error: {
 					code: "500",
@@ -80,23 +103,23 @@ describe("GraphErrorHandler.ts", () => {
 					},
 				},
 			};
-			const gError = GraphErrorHandler.getError(errorResponse);
+			const gError = await GraphErrorHandler.getError(errorResponse);
 			assert.equal(gError.requestId, "some random id");
 			assert.equal(gError.code, "500");
 			assert.equal(gError.message, "Internal Server Error");
 		});
 
-		it("Should construct error from error object", () => {
+		it("Should construct error from error object", async () => {
 			const error = new Error("Some Error");
 			error.name = "InvalidError";
-			const gError = GraphErrorHandler.getError(error);
+			const gError = await GraphErrorHandler.getError(error);
 			assert.equal(gError.requestId, null);
 			assert.equal(gError.message, "Some Error");
 			assert.equal(gError.code, "InvalidError");
 		});
 
-		it("Should construct some default error", () => {
-			const gError = GraphErrorHandler.getError();
+		it("Should construct some default error", async () => {
+			const gError = await GraphErrorHandler.getError();
 			assert.equal(gError.statusCode, -1);
 			assert.equal(gError.code, null);
 			assert.equal(gError.message, null);

spec/core/GraphResponseHandler.ts

@@ -58,13 +58,6 @@ describe("GraphResponseHandler.ts", () => {
 			assert.equal(responseValue, htmlString);
 		});
 
-		it("Should return a raw response", async () => {
-			const response = new Response(htmlString, status200);
-			const responseValue = await GraphResponseHandler["convertResponse"](response, ResponseType.RAW);
-			assert.isDefined(responseValue);
-			assert.isTrue(responseValue instanceof Response);
-		});
-
 		it("Should return response value as text for text/html return type", async () => {
 			const response = new Response(htmlString, status200);
 			const responseValue = await GraphResponseHandler["convertResponse"](response, ResponseType.DOCUMENT);
@@ -92,20 +85,28 @@ describe("GraphResponseHandler.ts", () => {
 	/* tslint:enable: no-string-literal */
 
 	describe("getResponse", () => {
+		it("Should return a raw response", async () => {
+			const response = new Response(htmlString, status200);
+			const responseValue = await GraphResponseHandler.getResponse(response, ResponseType.RAW);
+			assert.isDefined(responseValue);
+			assert.isTrue(responseValue instanceof Response);
+		});
+
 		it("Should return valid 200 OK response", async () => {
 			const response = new Response(htmlString, status200);
 			const responseValue = await GraphResponseHandler.getResponse(response, ResponseType.TEXT);
 			assert.isDefined(responseValue);
 		});
 
-		it("Should throw error for NOT OK response", async () => {
+		it("Should parse from raw response for NOT OK response", async () => {
 			try {
 				const response = new Response("NOT OK", status500);
 				const responseValue = await GraphResponseHandler.getResponse(response, ResponseType.TEXT);
 				throw new Error("Something wrong with validating OK response");
 			} catch (error) {
 				assert.isDefined(error);
-				assert.equal(error, "NOT OK");
+				assert.isTrue(error instanceof Response);
+				assert.equal(error.status, 500);
 			}
 		});
 	});

spec/middleware/RetryHandler.ts

@@ -166,24 +166,34 @@ describe("RetryHandler.ts", function() {
 			assert.isDefined(delay);
 		});
 
+		it("Should return delay without exponential backoff", () => {
+			const delay = retryHandler["getDelay"](gatewayTimeoutResponse, 1, 10);
+			assert.isAbove(delay, 10);
+			assert.isBelow(delay, 11);
+		});
+
+		it("Should return delay with exponential backoff", () => {
+			const delay = retryHandler["getDelay"](gatewayTimeoutResponse, 2, 10);
+			assert.isAbove(delay, 12);
+			assert.isBelow(delay, 13);
+		});
+
 		it("Should return max delay for if the calculated delay is more", () => {
-			const delay = retryHandler["getDelay"](gatewayTimeoutResponse, 0, 1);
-			assert.isAbove(delay, 0);
-			assert.isBelow(delay, 1);
+			const delay = retryHandler["getDelay"](gatewayTimeoutResponse, 10, 100);
+			assert.isAbove(delay, 180);
+			assert.isBelow(delay, 181);
 		});
 	});
 
 	describe("getExponentialBackOffTime", () => {
 		it("Should return 0 delay for 0th attempt i.e for a fresh request", () => {
 			const time = retryHandler["getExponentialBackOffTime"](0);
-			assert.isAbove(time, 0);
-			assert.isBelow(time, 1);
+			assert.equal(time, 0);
 		});
 
 		it("Should return attempt time", () => {
 			const time = retryHandler["getExponentialBackOffTime"](1);
-			assert.isAbove(time, 1);
-			assert.isBelow(time, 2);
+			assert.equal(time, 1);
 		});
 	});
 

spec/tasks/PageIterator.ts

@@ -47,12 +47,6 @@ const truthyCallback: PageIteratorCallback = (data) => {
 	return true;
 };
 
-let truthyCallbackCounter = 5;
-const truthyCallbackWithCounter: PageIteratorCallback = (data) => {
-	truthyCallbackCounter--;
-	return true;
-};
-
 let halfWayCallbackCounter = 5;
 const halfWayCallback: PageIteratorCallback = (data) => {
 	halfWayCallbackCounter--;
@@ -78,11 +72,10 @@ describe("PageIterator.ts", () => {
 
 	describe("iterate", () => {
 		it("Should iterate over a complete collection without nextLink", async () => {
-			truthyCallbackCounter = 10;
-			const pageIterator = new PageIterator(client, getPageCollection(), truthyCallbackWithCounter);
+			const pageIterator = new PageIterator(client, getPageCollection(), truthyCallback);
 			try {
 				await pageIterator.iterate();
-				assert.equal(truthyCallbackCounter, 0);
+				assert.isTrue(pageIterator.isComplete());
 			} catch (error) {
 				throw error;
 			}
@@ -104,7 +97,7 @@ describe("PageIterator.ts", () => {
 			halfWayCallbackCounter = 5;
 			try {
 				await pageIterator.iterate();
-				assert.equal(halfWayCallbackCounter, 0);
+				assert.isFalse(pageIterator.isComplete());
 			} catch (error) {
 				throw error;
 			}
@@ -123,21 +116,43 @@ describe("PageIterator.ts", () => {
 			}
 		});
 	});
-	/* tslint:enable: no-string-literal */
 
 	describe("resume", () => {
 		it("Should start from the place where it left the iteration", async () => {
 			const pageIterator = new PageIterator(client, getPageCollection(), halfWayCallback);
 			halfWayCallbackCounter = 5;
 			try {
 				await pageIterator.iterate();
-				assert.equal(halfWayCallbackCounter, 0);
-				halfWayCallbackCounter = 5;
+				assert.isFalse(pageIterator.isComplete());
 				await pageIterator.resume();
-				assert.equal(halfWayCallbackCounter, 0);
+				assert.isTrue(pageIterator.isComplete());
+			} catch (error) {
+				throw error;
+			}
+		});
+	});
+
+	describe("isComplete", () => {
+		it("Should return false for incomplete iteration", async () => {
+			const pageIterator = new PageIterator(client, getPageCollection(), halfWayCallback);
+			halfWayCallbackCounter = 5;
+			try {
+				await pageIterator.iterate();
+				assert.isFalse(pageIterator.isComplete());
+			} catch (error) {
+				throw error;
+			}
+		});
+
+		it("Should return true for complete iteration", async () => {
+			const pageIterator = new PageIterator(client, getPageCollection(), truthyCallback);
+			try {
+				await pageIterator.iterate();
+				assert.isTrue(pageIterator.isComplete());
 			} catch (error) {
 				throw error;
 			}
 		});
 	});
+	/* tslint:enable: no-string-literal */
 });

src/GraphErrorHandler.ts

@@ -40,10 +40,30 @@ export class GraphErrorHandler {
 	/**
 	 * @private
 	 * @static
+	 * @async
+	 * To construct error from the raw response
+	 * @param {Response} error - The error response
+	 * @param {number} statusCode - The status code of the response
+	 * @returns A promise that resolves to GraphError instance
+	 */
+	private static async constructErrorFromRawResponse(error: Response, statusCode: number): Promise<GraphError> {
+		const gError = new GraphError(statusCode);
+		try {
+			gError.body = await error.text();
+		} catch (error) {
+			// tslint:disable-line: no-empty
+		}
+		return gError;
+	}
+
+	/**
+	 * @private
+	 * @static
+	 * @async
 	 * Populates the GraphError instance from the Error returned by graph service
 	 * @param {any} error - The error returned by graph service or some native error
 	 * @param {number} statusCode - The status code of the response
-	 * @returns The GraphError instance
+	 * @returns A promise that resolves to GraphError instance
 	 *
 	 * Example error for https://graph.microsoft.com/v1.0/me/events?$top=3&$search=foo
 	 * {
@@ -77,15 +97,18 @@ export class GraphErrorHandler {
 	/**
 	 * @public
 	 * @static
+	 * @async
 	 * To get the GraphError object
 	 * @param {any} [error = null] - The error returned by graph service or some native error
 	 * @param {number} [statusCode = -1] - The status code of the response
 	 * @param {GraphRequestCallback} [callback] - The graph request callback function
-	 * @returns The GraphError instance
+	 * @returns A promise that resolves to GraphError instance
 	 */
-	public static getError(error: any = null, statusCode: number = -1, callback?: GraphRequestCallback): GraphError {
+	public static async getError(error: any = null, statusCode: number = -1, callback?: GraphRequestCallback): Promise<GraphError> {
 		let gError: GraphError;
-		if (error && error.error) {
+		if (error instanceof Response) {
+			gError = await GraphErrorHandler.constructErrorFromRawResponse(error, statusCode);
+		} else if (error && error.error) {
 			gError = GraphErrorHandler.constructErrorFromResponse(error, statusCode);
 		} else if (error instanceof Error) {
 			gError = GraphErrorHandler.constructError(error, statusCode);

src/GraphRequest.ts

@@ -302,7 +302,7 @@ export class GraphRequest {
 			if (typeof rawResponse !== "undefined") {
 				statusCode = rawResponse.status;
 			}
-			const gError: GraphError = GraphErrorHandler.getError(error, statusCode, callback);
+			const gError: GraphError = await GraphErrorHandler.getError(error, statusCode, callback);
 			throw gError;
 		}
 	}