Release - 2.1.0

README.md

@@ -95,6 +95,7 @@ npm install msal@<version>
 
 ```typescript
 import { UserAgentApplication } from "msal";
+
 import { ImplicitMSALAuthenticationProvider } from "@microsoft/microsoft-graph-client/lib/src/ImplicitMSALAuthenticationProvider";
 import { MSALAuthenticationProviderOptions } from '@microsoft/microsoft-graph-client/lib/src/MSALAuthenticationProviderOptions';
 

docs/Actions.md

@@ -29,13 +29,13 @@ client
 .then((stream) => {
 let writeStream = fs.createWriteStream(`../<DOWNLOAD_FILE_NAME>`); // Eg: test.pdf
 stream.pipe(writeStream).on("error", (err) => {
-throw error;
+throw err;
 });
 writeStream.on("finish", () => {
 console.log("Downloaded");
 });
 writeStream.on("error", (err) => {
-throw error;
+throw err;
 });
 })
 .catch((error) => {

docs/ChaosHandlerSamples.md

@@ -0,0 +1,102 @@
+# Testing Handler
+
+### How to include
+
+> Uses [Custom Middleware Chain](https://github.com/microsoftgraph/msgraph-sdk-javascript/blob/dev/docs/CustomMiddlewareChain.md), it's not included in default middleware chain
+
+### Modes in Chaos Handler
+
+- Manual mode - Setting the Response code manually. - Global/Client Level - Provide a map declared manually containing response code for the requests. - Request Level - Providing response code per request. This would be overriding the Global level response code (if any).
+- Random mode - We get a random Response code from a set of response code defined for each method.
+
+**A request Passes through to the Graph, if there is no entry for the request**
+
+**Note - Always add ChaosHandler before HttpMessageHandler in the midllewareChain**
+
+### Samples
+
+```js
+require("isomorphic-fetch");
+const MicrosoftGraph = require("../../lib/src/index.js");
+const secrets = require("./secrets");
+const fs = require("fs");
+// Initialising the client
+const client = MicrosoftGraph.Client.init({
+defaultVersion: "v1.0",
+debugLogging: true,
+authProvider: (done) => {
+done(null, secrets.accessToken);
+},
+});
+
+/*
+Create a custom MiddlewareChain passing information in this way
+
+const manualMap = new Map([["/me/messages/.*", new Map([["GET", 429], ["PATCH", 429]])], ["/me", new Map([["POST", 502]])]]);
+const chaosHandler = new MicrosoftGraph.ChaosHandler(new MicrosoftGraph.ChaosHandlerOptions(MicrosoftGraph.ChaosStrategy.MANUAL), manualMap);
+*/
+
+// This request would use the Map (Manual mode)
+const mail = {
+subject: "Chaos Handler Samples",
+toRecipients: [
+{
+emailAddress: {
+address: "admin@M365x003297.OnMicrosoft.com",
+},
+},
+],
+body: {
+content: "<h1>Testing Handler Samples Sample</h1><br>https://github.com/microsoftgraph/msgraph-sdk-javascript",
+contentType: "html",
+},
+};
+client
+.api("/users/me/sendMail")
+.post({
+message: mail,
+})
+.then((res) => {
+console.log(res, "This is for sendMail");
+})
+.catch((err) => {
+console.log(err, "This is for sendMail in error case");
+});
+
+// OverRiding to Random mode, providing the chaos percentage as 60(percentage times the error would be generated from handler)
+client
+.api("/me")
+.middlewareOptions([new MicrosoftGraph.ChaosHandlerOptions(MicrosoftGraph.ChaosStrategy.RANDOM, "I generated the error", undefined, 60)])
+.get()
+.then((res) => {
+console.log(res);
+})
+.catch((err) => {
+console.log(err);
+});
+
+// This request is passed to the graph and gets a response from the graph, as no entry for /me GET request in the Map
+client
+.api("/me")
+.get()
+.then((res) => {
+console.log("Found", res, "users");
+})
+.catch((err) => {
+console.log(err, "!!!!!!!!!");
+});
+
+// Using Manual Map with regex matching
+client
+.api("/me/messages/hjdlfslod-fdssdkjfs-6zdkmghs-sadhsu2")
+.header("content-type", "application/json")
+.update({
+birthday: "1908-12-22T00:00:00Z",
+})
+.then((res) => {
+console.log("This is regex matching... Updated Bday");
+})
+.catch((err) => {
+console.log(err, "matched");
+});
+```

docs/CustomAuthenticationProvider.md

@@ -18,7 +18,7 @@ class MyAuthenticationProvider implements AuthenticationProvider {
  * This should return a Promise that resolves to an accessToken (in case of success) or rejects with error (in case of failure)
  * Basically this method will contain the implementation for getting and refreshing accessTokens
  */
-public async getAccessToken(): Promise<any> {}
+public async getAccessToken(): Promise<string> {}
 }
 ```
 
@@ -30,7 +30,7 @@ Pass instance of MyAuthenticationProvider while initializing.
 import { MyAuthenticationProvider } from "./MyAuthenticationProvider";
 
 let clientOptions: ClientOptions = {
-authProvider: new MyCustomAuthenticationProvider(),
+authProvider: new MyAuthenticationProvider(),
 };
 const client = Client.initWithMiddleware(clientOptions);
 ```

docs/CustomMiddlewareChain.md

@@ -144,4 +144,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.

docs/GettingRawResponse.md

@@ -4,7 +4,7 @@ Steps for getting the raw response [i.e [Response Object](https://developer.mozi
 
 ## Initialize the Client
 
-Refer [this documentation](../CreatingClientInstance.md) for initializing the client.
+Refer [this documentation](./CreatingClientInstance.md) for initializing the client.
 
 ## Getting Raw Response by setting ResponseType
 

docs/tasks/LargeFileUploadTask.md

@@ -104,7 +104,7 @@ _You can pass in the customized options using LargeFileUploadTask_
 
 ```typescript
 async function largeFileUpload(client, file) {
-const filename = file.name;
+const fileName = file.name;
 const driveId = "<YOUR_DRIVE_ID>";
 const path = "<LOCATION_TO_STORE_FILE>";
 try {

package.json

@@ -1,7 +1,8 @@
 {
 "name": "@microsoft/microsoft-graph-client",
-"version": "2.0.0",
+"version": "2.1.0",
 "description": "Microsoft Graph Client Library",
+"license": "MIT",
 "main": "lib/src/index.js",
 "module": "lib/es/index.js",
 "typings": "lib/src/index",

spec/core/Client.ts

@@ -8,10 +8,15 @@
 import { assert } from "chai";
 import "isomorphic-fetch";
 
+import { CustomAuthenticationProvider, TelemetryHandler } from "../../src";
 import { Client } from "../../src/Client";
 import { AuthProvider } from "../../src/IAuthProvider";
 import { ClientOptions } from "../../src/IClientOptions";
 import { Options } from "../../src/IOptions";
+import { AuthenticationHandler } from "../../src/middleware/AuthenticationHandler";
+import { ChaosHandler } from "../../src/middleware/ChaosHandler";
+import { ChaosHandlerOptions } from "../../src/middleware/options/ChaosHandlerOptions";
+import { ChaosStrategy } from "../../src/middleware/options/ChaosStrategy";
 import { DummyAuthenticationProvider } from "../DummyAuthenticationProvider";
 import { DummyHTTPMessageHandler } from "../DummyHTTPMessageHandler";
 
@@ -61,6 +66,41 @@ describe("Client.ts", () => {
 assert.equal(error.name, "InvalidMiddlewareChain");
 }
 });
+
+it("Init middleware using a middleware array", async () => {
+const provider: AuthProvider = (done) => {
+done(null, "dummy_token");
+};
+const authHandler = new AuthenticationHandler(new CustomAuthenticationProvider(provider));
+const responseBody = "Test response body";
+const options = new ChaosHandlerOptions(ChaosStrategy.MANUAL, "Testing middleware array", 200, 0, responseBody);
+const middlewareArray = [authHandler, new ChaosHandler(options)];
+const client = Client.initWithMiddleware({ middleware: middlewareArray });
+
+const response = await client.api("me").get();
+assert.equal(response, responseBody);
+});
+
+it("Init middleware using a chained middleware array", async () => {
+const provider: AuthProvider = (done) => {
+done(null, "dummy_token");
+};
+const authHandler = new AuthenticationHandler(new CustomAuthenticationProvider(provider));
+
+const responseBody = "Test response body";
+const options = new ChaosHandlerOptions(ChaosStrategy.MANUAL, "Testing chained middleware array", 200, 0, responseBody);
+const chaosHandler = new ChaosHandler(options);
+const telemetryHandler = new TelemetryHandler();
+
+authHandler.setNext(telemetryHandler);
+telemetryHandler.setNext(chaosHandler);
+
+const middlewareArray = [authHandler];
+const client = Client.initWithMiddleware({ middleware: middlewareArray });
+
+const response = await client.api("me").get();
+assert.equal(response, responseBody);
+});
 });
 
 describe("init", () => {

spec/core/GraphErrorHandler.ts

@@ -97,9 +97,9 @@ describe("GraphErrorHandler.ts", () => {
 
 it("Should construct some default error", async () => {
 const gError = await GraphErrorHandler.getError();
+assert.equal(gError.message, "");
 assert.equal(gError.statusCode, -1);
 assert.equal(gError.code, null);
-assert.equal(gError.message, null);
 assert.equal(gError.body, null);
 assert.equal(gError.requestId, null);
 });