microsoftgraph · nikithauc · Aug 16, 2019 · Aug 22, 2019 · Aug 27, 2019 · Sep 16, 2019
diff --git a/docs/CustomMiddlewareChain.md b/docs/CustomMiddlewareChain.md
@@ -143,5 +143,4 @@ export class MyLoggingHandler implements Middleware {
 	}
 }
 ```
-
-Refer [MiddlewareOptions](../src/middleware/option/IMiddlewareOptions.ts) interface to know its structure.
+Refer [MiddlewareOptions](../src/middleware/options/IMiddlewareOptions.ts) interface to know its structure.
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
 	"name": "@microsoft/microsoft-graph-client",
-	"version": "2.0.0",
+	"version": "2.1.0",
 	"description": "Microsoft Graph Client Library",
 	"main": "lib/src/index.js",
 	"module": "lib/es/index.js",

diff --git a/spec/core/GraphRequestUtil.ts b/spec/core/GraphRequestUtil.ts
@@ -61,10 +61,15 @@ describe("GraphRequestUtil.ts", () => {
 			node2.link = node1;
 			try {
 				serializeContent(node1);
-				throw new Error("Something wrong with the serialize content, it should stringify cyclic referenced objects");
+				throw new Error("Something wrong with the serialize content, it should not stringify cyclic referenced objects");
 			} catch (error) {
 				assert.equal(error.message, "Unable to stringify the content");
 			}
 		});
+
+		it("Should return undefined for the case of undefined content value", () => {
+			const val = undefined;
+			assert.equal(serializeContent(val), undefined);
+		});
 	});
 });
diff --git a/spec/core/HTTPClient.ts b/spec/core/HTTPClient.ts
@@ -7,9 +7,13 @@
 
 import { assert } from "chai";
 
+import { Client } from "../../src/Client";
 import { HTTPClient } from "../../src/HTTPClient";
 import { Context } from "../../src/IContext";
 import { FetchOptions } from "../../src/IFetchOptions";
+import { RedirectHandlerOptions } from "../../src/middleware/options/RedirectHandlerOptions";
+import { RedirectHandler } from "../../src/middleware/RedirectHandler";
+import { TelemetryHandler } from "../../src/middleware/TelemetryHandler";
 import { DummyHTTPMessageHandler } from "../DummyHTTPMessageHandler";
 
 describe("HTTPClient.ts", () => {
@@ -68,4 +72,39 @@ describe("HTTPClient.ts", () => {
 			}
 		});
 	});
+
+	describe("getMiddlewareArray", () => {
+		it("Should work fine for a single middleware in the chain, which does have a getNext method", () => {
+			const telemetryHandler = new TelemetryHandler();
+			const tempHttpClient: HTTPClient = new HTTPClient(telemetryHandler);
+			assert.equal(tempHttpClient.getMiddlewareArray().length, 1);
+		});
+
+		it("Should work fine for a single middleware in the chain, which doesn't have a getNext method", () => {
+			const tempHttpClient: HTTPClient = new HTTPClient(httpMessageHandler);
+			assert.equal(tempHttpClient.getMiddlewareArray().length, 1);
+		});
+
+		it("Should work fine for a chain containing many middlewares", () => {
+			const telemetryHandler = new TelemetryHandler();
+			const redirectHandler = new RedirectHandler(new RedirectHandlerOptions());
+			redirectHandler.setNext(telemetryHandler);
+			telemetryHandler.setNext(httpMessageHandler);
+			const tempHttpClient: HTTPClient = new HTTPClient(redirectHandler);
+			assert.equal(tempHttpClient.getMiddlewareArray().length, 3);
+		});
+	});
+
+	describe("setMiddlewareArray", () => {
+		it("Should make a chain out of the provided array of middlewares", () => {
+			const telemetryHandler = new TelemetryHandler();
+			const redirectHandler = new RedirectHandler(new RedirectHandlerOptions());
+			redirectHandler.setNext(httpMessageHandler);
+			const tempHttpClient: HTTPClient = new HTTPClient(redirectHandler);
+			const middlewareArray = tempHttpClient.getMiddlewareArray();
+			middlewareArray.splice(1, 0, telemetryHandler);
+			tempHttpClient.setMiddlewareArray(middlewareArray);
+			assert.equal(tempHttpClient.getMiddlewareArray().length, 3);
+		});
+	});
 });
diff --git a/src/Client.ts b/src/Client.ts
@@ -16,6 +16,7 @@ import { HTTPClient } from "./HTTPClient";
 import { HTTPClientFactory } from "./HTTPClientFactory";
 import { ClientOptions } from "./IClientOptions";
 import { Options } from "./IOptions";
+import { Middleware } from "./middleware/IMiddleware";
 import { validatePolyFilling } from "./ValidatePolyFilling";
 
 export class Client {
@@ -103,6 +104,24 @@ export class Client {
 		this.httpClient = httpClient;
 	}
 
+	/**
+	 * @public
+	 * function to get the array of middlewares in use right now
+	 * @returns An array of middlewares
+	 */
+	public getMiddlewareChain() {
+		return this.httpClient.getMiddlewareArray();
+	}
+
+	/**
+	 * @public
+	 * function to set the middleware chain
+	 * @param {Middleware[]} middlewareArray - An array of middlewares
+	 */
+	public setMiddlewareChain(middlewareArray: Middleware[]) {
+		return this.httpClient.setMiddlewareArray(middlewareArray);
+	}
+
 	/**
 	 * @public
 	 * Entry point to make requests

diff --git a/src/GraphRequest.ts b/src/GraphRequest.ts
@@ -489,7 +489,7 @@ export class GraphRequest {
 	 * @param {boolean} isCount - The count boolean
 	 * @returns The same GraphRequest instance that is being called with
 	 */
-	public count(isCount: boolean): GraphRequest {
+	public count(isCount: boolean = false): GraphRequest {
 		this.urlComponents.oDataQueryParams.$count = isCount.toString();
 		return this;
 	}

diff --git a/src/GraphRequestUtil.ts b/src/GraphRequestUtil.ts
@@ -41,7 +41,7 @@ export const urlJoin = (urlSegments: string[]): string => {
  */
 
 export const serializeContent = (content: any): any => {
-	const className: string = content.constructor.name;
+	const className: string = content && content.constructor && content.constructor.name;
 	if (className === "Buffer" || className === "Blob" || className === "File" || className === "FormData" || typeof content === "string") {
 		return content;
 	}

diff --git a/src/HTTPClient.ts b/src/HTTPClient.ts
@@ -33,6 +33,37 @@ export class HTTPClient {
 		this.middleware = middleware;
 	}
 
+	/**
+	 * @public
+	 * To get an array of Middleware, used in middleware chain
+	 * @returns An array of middlewares
+	 */
+	public getMiddlewareArray(): Middleware[] {
+		const middlewareArray: Middleware[] = [];
+		let currentMiddleware = this.middleware;
+		while (currentMiddleware) {
+			middlewareArray.push(currentMiddleware);
+			if (currentMiddleware.getNext) {
+				currentMiddleware = currentMiddleware.getNext();
+			} else {
+				break;
+			}
+		}
+		return middlewareArray;
+	}
+
+	/**
+	 * @public
+	 * To set the middleware chain
+	 * @param {Middleware[]} middlewareArray - The array containing the middlewares
+	 */
+	public setMiddlewareArray(middlewareArray: Middleware[]) {
+		for (let num = 0; num < middlewareArray.length - 1; num += 1) {
+			middlewareArray[num].setNext(middlewareArray[num + 1]);
+		}
+		this.middleware = middlewareArray[0];
+	}
+
 	/**
 	 * @public
 	 * @async

diff --git a/src/Version.ts b/src/Version.ts
@@ -12,4 +12,4 @@
  * @module Version
  */
 
-export const PACKAGE_VERSION = "2.0.0";
+export const PACKAGE_VERSION = "2.1.0";
diff --git a/src/middleware/AuthenticationHandler.ts b/src/middleware/AuthenticationHandler.ts
@@ -94,4 +94,13 @@ export class AuthenticationHandler implements Middleware {
 	public setNext(next: Middleware): void {
 		this.nextMiddleware = next;
 	}
+
+	/**
+	 * @public
+	 * To get the next middleware in the chain
+	 * @returns next Middleware instance
+	 */
+	public getNext(): Middleware {
+		return this.nextMiddleware;
+	}
 }
diff --git a/src/middleware/IMiddleware.ts b/src/middleware/IMiddleware.ts
@@ -15,4 +15,5 @@ import { Context } from "../IContext";
 export interface Middleware {
 	execute: (context: Context) => Promise<void>;
 	setNext?: (middleware: Middleware) => void;
+	getNext?: () => Middleware;
 }
diff --git a/src/middleware/RedirectHandler.ts b/src/middleware/RedirectHandler.ts
@@ -243,4 +243,13 @@ export class RedirectHandler implements Middleware {
 	public setNext(next: Middleware): void {
 		this.nextMiddleware = next;
 	}
+
+	/**
+	 * @public
+	 * To get the next middleware in the chain
+	 * @returns next Middleware instance
+	 */
+	public getNext(): Middleware {
+		return this.nextMiddleware;
+	}
 }
diff --git a/src/middleware/RetryHandler.ts b/src/middleware/RetryHandler.ts
@@ -216,4 +216,13 @@ export class RetryHandler implements Middleware {
 	public setNext(next: Middleware): void {
 		this.nextMiddleware = next;
 	}
+
+	/**
+	 * @public
+	 * To get the next middleware in the chain
+	 * @returns next Middleware instance
+	 */
+	public getNext(): Middleware {
+		return this.nextMiddleware;
+	}
 }
diff --git a/src/middleware/TelemetryHandler.ts b/src/middleware/TelemetryHandler.ts
@@ -96,4 +96,13 @@ export class TelemetryHandler implements Middleware {
 	public setNext(next: Middleware): void {
 		this.nextMiddleware = next;
 	}
+
+	/**
+	 * @public
+	 * To get the next middleware in the chain
+	 * @returns next Middleware instance
+	 */
+	public getNext(): Middleware {
+		return this.nextMiddleware;
+	}
 }
-Original file line number
+Diff line change
@@ Expand Up / @@ -143,5 +143,4 @@ export class MyLoggingHandler implements Middleware { @@
     	}
     }
     ```
-    Refer [MiddlewareOptions](../src/middleware/option/IMiddlewareOptions.ts) interface to know its structure.
+    Refer [MiddlewareOptions](../src/middleware/options/IMiddlewareOptions.ts) interface to know its structure.